@qwen-code/qwen-code 0.18.1-preview.0 → 0.18.1-preview.1

package/chunks/{chunk-6WPY6ES3.js → chunk-ZNUMXPNK.js}

@@ -3231,7 +3231,7 @@ var require_compile = __commonJS({
     }
     __name(compileSchema, "compileSchema");
     exports.compileSchema = compileSchema;
-    function resolveRef(root, baseId, ref) {
+    function resolveRef2(root, baseId, ref) {
       var _a;
       ref = (0, resolve_1.resolveUrl)(this.opts.uriResolver, baseId, ref);
       const schOrFunc = root.refs[ref];
@@ -3248,8 +3248,8 @@ var require_compile = __commonJS({
         return;
       return root.refs[ref] = inlineOrCompile.call(this, _sch);
     }
-    __name(resolveRef, "resolveRef");
-    exports.resolveRef = resolveRef;
+    __name(resolveRef2, "resolveRef");
+    exports.resolveRef = resolveRef2;
     function inlineOrCompile(sch) {
       if ((0, resolve_1.inlineRef)(sch.schema, this.opts.inlineRefs))
         return sch.schema;
@@ -11098,7 +11098,7 @@ var require_compile2 = __commonJS({
     }
     __name(compileSchema, "compileSchema");
     exports.compileSchema = compileSchema;
-    function resolveRef(root, baseId, ref) {
+    function resolveRef2(root, baseId, ref) {
       var _a;
       ref = (0, resolve_1.resolveUrl)(this.opts.uriResolver, baseId, ref);
       const schOrFunc = root.refs[ref];
@@ -11115,8 +11115,8 @@ var require_compile2 = __commonJS({
         return;
       return root.refs[ref] = inlineOrCompile.call(this, _sch);
     }
-    __name(resolveRef, "resolveRef");
-    exports.resolveRef = resolveRef;
+    __name(resolveRef2, "resolveRef");
+    exports.resolveRef = resolveRef2;
     function inlineOrCompile(sch) {
       if ((0, resolve_1.inlineRef)(sch.schema, this.opts.inlineRefs))
         return sch.schema;
@@ -14284,10 +14284,17 @@ var SchemaValidator = class {
     if (!valid && validate.errors) {
       fixBooleanValues(
         data,
+        anySchema,
+        anySchema
+      );
+      fixStringValues(
+        data,
+        anySchema,
         anySchema
       );
       fixStringifiedJsonValues(
         data,
+        anySchema,
         anySchema
       );
       fixNumericValues(
@@ -14302,49 +14309,371 @@ var SchemaValidator = class {
     return null;
   }
 };
-function getAcceptedTypes(propSchema) {
-  const types = /* @__PURE__ */ new Set();
-  if (typeof propSchema["type"] === "string") {
-    types.add(propSchema["type"]);
-  } else if (Array.isArray(propSchema["type"])) {
-    for (const t of propSchema["type"]) {
-      types.add(t);
+function resolveRef(ref, rootSchema) {
+  if (!ref.startsWith("#/")) return null;
+  const parts = ref.slice(2).split("/");
+  let current = rootSchema;
+  for (const rawPart of parts) {
+    if (current == null || typeof current !== "object") return null;
+    const part = rawPart.replace(/~1/g, "/").replace(/~0/g, "~");
+    if (!Object.hasOwn(current, part)) return null;
+    current = current[part];
+  }
+  if (current != null && typeof current === "object" && !Array.isArray(current)) {
+    return current;
+  }
+  return null;
+}
+__name(resolveRef, "resolveRef");
+function resolvePropSchema(propSchema, rootSchema) {
+  if (!propSchema) return void 0;
+  let schema = propSchema;
+  let depth = 0;
+  while (typeof schema["$ref"] === "string" && depth < 64) {
+    depth++;
+    const resolved = resolveRef(schema["$ref"], rootSchema);
+    if (!resolved) return propSchema;
+    schema = resolved;
+  }
+  return schema;
+}
+__name(resolvePropSchema, "resolvePropSchema");
+function resolveArrayElementSchema(parentSchema, rootSchema, index) {
+  const prefixItems = parentSchema["prefixItems"];
+  if (prefixItems && index < prefixItems.length) {
+    const entry = prefixItems[index];
+    if (typeof entry === "object" && entry !== null && !Array.isArray(entry)) {
+      return resolvePropSchema(entry, rootSchema);
+    }
+    return void 0;
+  }
+  const itemsSchema = parentSchema["items"];
+  if (itemsSchema) {
+    return resolvePropSchema(itemsSchema, rootSchema);
+  }
+  return void 0;
+}
+__name(resolveArrayElementSchema, "resolveArrayElementSchema");
+function getCompositionVariants(schema, rootSchema) {
+  const variants = [];
+  for (const keyword of ["allOf", "anyOf", "oneOf"]) {
+    const val = schema[keyword];
+    if (Array.isArray(val)) {
+      for (const item of val) {
+        if (typeof item === "object" && item != null && !Array.isArray(item)) {
+          const resolved = rootSchema ? resolvePropSchema(item, rootSchema) : item;
+          if (resolved) variants.push(resolved);
+        }
+      }
     }
   }
-  for (const keyword of ["anyOf", "oneOf"]) {
-    const variants = propSchema[keyword];
-    if (Array.isArray(variants)) {
-      for (const variant of variants) {
-        if (typeof variant["type"] === "string") {
-          types.add(variant["type"]);
-        } else if (Array.isArray(variant["type"])) {
-          for (const t of variant["type"]) {
-            types.add(t);
+  return variants;
+}
+__name(getCompositionVariants, "getCompositionVariants");
+function schemaHasObjectShape(schema, rootSchema) {
+  if (schema["properties"] || schema["additionalProperties"]) return true;
+  for (const variant of getCompositionVariants(schema, rootSchema)) {
+    if (variant["properties"] || variant["additionalProperties"]) return true;
+  }
+  return false;
+}
+__name(schemaHasObjectShape, "schemaHasObjectShape");
+var DANGEROUS_PROP_KEYS = /* @__PURE__ */ new Set(["__proto__", "constructor", "prototype"]);
+function getEffectiveProperties(schema, rootSchema) {
+  const merged = /* @__PURE__ */ Object.create(null);
+  for (const variant of getCompositionVariants(schema, rootSchema)) {
+    const variantProps = variant["properties"];
+    if (variantProps) {
+      for (const [k, v] of Object.entries(variantProps)) {
+        if (DANGEROUS_PROP_KEYS.has(k)) continue;
+        if (!Object.hasOwn(merged, k)) merged[k] = v;
+      }
+    }
+  }
+  const topProps = schema["properties"];
+  if (topProps) {
+    for (const [k, v] of Object.entries(topProps)) {
+      if (DANGEROUS_PROP_KEYS.has(k)) continue;
+      merged[k] = v;
+    }
+  }
+  return Object.keys(merged).length > 0 ? merged : void 0;
+}
+__name(getEffectiveProperties, "getEffectiveProperties");
+function getAcceptedTypes(propSchema, rootSchema, depth = 0, cache = /* @__PURE__ */ new WeakMap()) {
+  if (depth > 64) return null;
+  let schema = propSchema;
+  if (typeof schema["$ref"] === "string" && rootSchema) {
+    const resolved = resolvePropSchema(propSchema, rootSchema);
+    if (!resolved || typeof resolved["$ref"] === "string") {
+      return null;
+    }
+    schema = resolved;
+  }
+  const cacheable = typeof schema === "object" && schema !== null;
+  if (cacheable) {
+    const cached = cache.get(schema);
+    if (cached !== void 0) return cached;
+  }
+  const types = /* @__PURE__ */ new Set();
+  if (typeof schema === "object" && schema !== null) {
+    if (typeof schema["type"] === "string") {
+      types.add(schema["type"]);
+    } else if (Array.isArray(schema["type"])) {
+      for (const t of schema["type"]) {
+        types.add(t);
+      }
+    }
+    for (const keyword of ["anyOf", "oneOf", "allOf"]) {
+      const variants = schema[keyword];
+      if (Array.isArray(variants)) {
+        for (const variant of variants) {
+          const nested = getAcceptedTypes(
+            variant,
+            rootSchema,
+            depth + 1,
+            cache
+          );
+          if (nested) {
+            for (const t of nested) {
+              types.add(t);
+            }
           }
         }
       }
     }
   }
-  return types.size > 0 ? types : null;
+  const result = types.size > 0 ? types : null;
+  if (cacheable) cache.set(schema, result);
+  return result;
 }
 __name(getAcceptedTypes, "getAcceptedTypes");
-function fixStringifiedJsonValues(data, schema) {
-  const properties = schema["properties"];
-  if (!properties) return;
+function valueToSchemaType(value) {
+  if (value === null) return "null";
+  if (typeof value === "boolean") return "boolean";
+  if (typeof value === "bigint") return "integer";
+  if (typeof value === "number") {
+    if (!Number.isFinite(value)) return null;
+    return Number.isInteger(value) ? "integer" : "number";
+  }
+  if (typeof value === "string") return "string";
+  if (Array.isArray(value)) return "array";
+  if (typeof value === "object") return "object";
+  return null;
+}
+__name(valueToSchemaType, "valueToSchemaType");
+function typeIsAccepted(valueType, accepted) {
+  if (accepted.has(valueType)) return true;
+  if (valueType === "integer" && accepted.has("number")) return true;
+  return false;
+}
+__name(typeIsAccepted, "typeIsAccepted");
+function fixStringifiedJsonValuesInArray(array, itemsSchema, root, key) {
+  if (Array.isArray(itemsSchema["prefixItems"])) {
+    for (let i = 0; i < array.length; i++) {
+      const elSchema = resolveArrayElementSchema(itemsSchema, root, i);
+      if (!elSchema) continue;
+      const item = array[i];
+      if (typeof item !== "string") continue;
+      const trimmed = item.trim();
+      if (trimmed.startsWith("[") && trimmed.endsWith("]") || trimmed.startsWith("{") && trimmed.endsWith("}")) {
+        const elAccepted = getAcceptedTypes(elSchema, root);
+        if (elAccepted && !elAccepted.has("string")) {
+          try {
+            const parsed = JSON.parse(trimmed);
+            const parsedType = Array.isArray(parsed) ? "array" : typeof parsed;
+            if (elAccepted.has(parsedType)) {
+              debugLogger.debug(
+                `coercion: ${key}[${i}] = ${String(item)} \u2192 ${JSON.stringify(parsed)} (accepted: ${[...elAccepted].join("|")})`
+              );
+              array[i] = parsed;
+            }
+          } catch {
+          }
+        }
+      }
+    }
+    return;
+  }
+  const resolvedItems = resolvePropSchema(itemsSchema, root);
+  if (!resolvedItems) return;
+  const innerItems = resolvedItems["items"];
+  const resolvedInner = innerItems ? resolvePropSchema(innerItems, root) : void 0;
+  const itemsAccepted = resolvedInner ? getAcceptedTypes(resolvedInner, root) : null;
+  if (!itemsAccepted || itemsAccepted.has("string")) return;
+  for (let i = 0; i < array.length; i++) {
+    const item = array[i];
+    if (typeof item !== "string") continue;
+    const trimmed = item.trim();
+    if (trimmed.startsWith("[") && trimmed.endsWith("]") || trimmed.startsWith("{") && trimmed.endsWith("}")) {
+      try {
+        const parsed = JSON.parse(trimmed);
+        const parsedType = Array.isArray(parsed) ? "array" : typeof parsed;
+        if (itemsAccepted.has(parsedType)) {
+          debugLogger.debug(
+            `coercion: ${key}[${i}] = ${String(item)} \u2192 ${JSON.stringify(parsed)} (accepted: ${[...itemsAccepted].join("|")})`
+          );
+          array[i] = parsed;
+        }
+      } catch {
+      }
+    }
+  }
+}
+__name(fixStringifiedJsonValuesInArray, "fixStringifiedJsonValuesInArray");
+function fixStringifiedJsonValues(data, schema, rootSchema, depth = 0) {
+  if (depth > 64) return;
+  const root = rootSchema ?? schema;
+  const properties = getEffectiveProperties(schema, root);
+  if (!properties && !schema["additionalProperties"]) return;
   for (const key of Object.keys(data)) {
     const value = data[key];
-    const propSchema = properties[key];
-    if (!propSchema || typeof value !== "string") continue;
+    const additionalProps = schema["additionalProperties"];
+    const propSchema = properties?.[key] ?? (typeof additionalProps === "object" && additionalProps !== null ? additionalProps : void 0);
+    if (!propSchema) continue;
+    const resolved = resolvePropSchema(
+      propSchema,
+      root
+    );
+    if (!resolved) continue;
+    if (typeof value === "object" && value !== null && !Array.isArray(value)) {
+      if (schemaHasObjectShape(resolved, root)) {
+        fixStringifiedJsonValues(
+          value,
+          resolved,
+          root,
+          depth + 1
+        );
+      }
+      continue;
+    }
+    if (Array.isArray(value)) {
+      if (Array.isArray(resolved["prefixItems"])) {
+        for (let i = 0; i < value.length; i++) {
+          const elSchema = resolveArrayElementSchema(resolved, root, i);
+          if (!elSchema) continue;
+          const item = value[i];
+          if (typeof item === "object" && item !== null && !Array.isArray(item)) {
+            if (schemaHasObjectShape(elSchema, root)) {
+              fixStringifiedJsonValues(
+                item,
+                elSchema,
+                root,
+                depth + 1
+              );
+            }
+          } else if (Array.isArray(item)) {
+            if (elSchema["type"] === "array" || elSchema["items"] || elSchema["prefixItems"]) {
+              fixStringifiedJsonValuesInArray(item, elSchema, root, key);
+            }
+          } else if (typeof item === "string") {
+            const elAccepted = getAcceptedTypes(elSchema, root);
+            if (elAccepted && !elAccepted.has("string")) {
+              const trimmed2 = item.trim();
+              if (trimmed2.startsWith("[") && trimmed2.endsWith("]") || trimmed2.startsWith("{") && trimmed2.endsWith("}")) {
+                try {
+                  const parsed = JSON.parse(trimmed2);
+                  const parsedType = Array.isArray(parsed) ? "array" : typeof parsed;
+                  if (elAccepted.has(parsedType)) {
+                    debugLogger.debug(
+                      `coercion: ${key}[${i}] = ${String(item)} \u2192 ${JSON.stringify(parsed)} (accepted: ${[...elAccepted].join("|")})`
+                    );
+                    value[i] = parsed;
+                  }
+                } catch {
+                }
+              }
+            }
+          }
+        }
+      } else {
+        const itemsSchema = resolved["items"];
+        if (itemsSchema) {
+          const resolvedItems = resolvePropSchema(itemsSchema, root);
+          if (!resolvedItems) continue;
+          if (schemaHasObjectShape(resolvedItems, root)) {
+            const itemsAccepted = getAcceptedTypes(resolvedItems, root);
+            for (let i = 0; i < value.length; i++) {
+              const item = value[i];
+              if (typeof item === "object" && item !== null && !Array.isArray(item)) {
+                fixStringifiedJsonValues(
+                  item,
+                  resolvedItems,
+                  root,
+                  depth + 1
+                );
+              } else if (typeof item === "string" && itemsAccepted && !itemsAccepted.has("string")) {
+                const trimmed2 = item.trim();
+                if (trimmed2.startsWith("{") && trimmed2.endsWith("}") || trimmed2.startsWith("[") && trimmed2.endsWith("]")) {
+                  try {
+                    const parsed = JSON.parse(trimmed2);
+                    if (itemsAccepted.has(
+                      Array.isArray(parsed) ? "array" : typeof parsed
+                    )) {
+                      debugLogger.debug(
+                        `coercion: ${key}[${i}] = ${String(item)} \u2192 ${JSON.stringify(parsed)} (accepted: ${[...itemsAccepted].join("|")})`
+                      );
+                      value[i] = parsed;
+                    }
+                  } catch {
+                  }
+                }
+              }
+            }
+          } else if (resolvedItems["type"] === "array" || resolvedItems["items"] || resolvedItems["prefixItems"]) {
+            for (const subArray of value) {
+              if (Array.isArray(subArray)) {
+                fixStringifiedJsonValuesInArray(
+                  subArray,
+                  resolvedItems,
+                  root,
+                  key
+                );
+              }
+            }
+          } else {
+            const itemsAccepted = getAcceptedTypes(resolvedItems, root);
+            if (itemsAccepted && !itemsAccepted.has("string")) {
+              for (let i = 0; i < value.length; i++) {
+                const item = value[i];
+                if (typeof item !== "string") continue;
+                const trimmed2 = item.trim();
+                if (trimmed2.startsWith("[") && trimmed2.endsWith("]") || trimmed2.startsWith("{") && trimmed2.endsWith("}")) {
+                  try {
+                    const parsed = JSON.parse(trimmed2);
+                    const parsedType = Array.isArray(parsed) ? "array" : typeof parsed;
+                    if (itemsAccepted.has(parsedType)) {
+                      debugLogger.debug(
+                        `coercion: ${key}[${i}] = ${String(item)} \u2192 ${JSON.stringify(parsed)} (accepted: ${[...itemsAccepted].join("|")})`
+                      );
+                      value[i] = parsed;
+                    }
+                  } catch {
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+      continue;
+    }
+    if (typeof value !== "string") continue;
     const trimmed = value.trim();
     if (trimmed.startsWith("[") && trimmed.endsWith("]") || trimmed.startsWith("{") && trimmed.endsWith("}")) {
-      const accepted = getAcceptedTypes(propSchema);
+      const accepted = getAcceptedTypes(resolved, root);
       if (!accepted) continue;
       if (accepted.has("string")) continue;
-      if (!accepted.has("array") && !accepted.has("object")) continue;
+      if (!accepted.has("array") && !accepted.has("object")) {
+        continue;
+      }
       try {
         const parsed = JSON.parse(trimmed);
         const parsedType = Array.isArray(parsed) ? "array" : typeof parsed;
         if (accepted.has(parsedType)) {
+          debugLogger.debug(
+            `coercion: ${key} = ${String(value)} \u2192 ${JSON.stringify(parsed)} (accepted: ${[...accepted].join("|")})`
+          );
           data[key] = parsed;
         }
       } catch {
@@ -14381,31 +14710,219 @@ function fixNumericValues(data, schema) {
   }
 }
 __name(fixNumericValues, "fixNumericValues");
-function fixBooleanValues(data, schema) {
-  const properties = schema?.["properties"];
-  const items = schema?.["items"];
+function fixBooleanValues(data, schema, rootSchema, depth = 0) {
+  if (depth > 64) return;
+  const root = rootSchema ?? schema;
+  const properties = getEffectiveProperties(schema, root);
+  if (!properties && !schema["additionalProperties"]) return;
   for (const key of Object.keys(data)) {
-    if (!(key in data)) continue;
     const value = data[key];
-    const childSchema = Array.isArray(data) ? items : properties?.[key];
+    const additionalProps = schema["additionalProperties"];
+    const propSchema = properties?.[key] ?? (typeof additionalProps === "object" && additionalProps !== null ? additionalProps : void 0);
+    const resolved = propSchema ? resolvePropSchema(propSchema, root) : void 0;
     if (typeof value === "object" && value !== null) {
-      fixBooleanValues(value, childSchema);
+      if (Array.isArray(value)) {
+        if (Array.isArray(resolved?.["prefixItems"])) {
+          for (let i = 0; i < value.length; i++) {
+            const elSchema = resolveArrayElementSchema(resolved, root, i);
+            if (!elSchema) continue;
+            const item = value[i];
+            if (typeof item === "object" && item !== null && !Array.isArray(item)) {
+              if (schemaHasObjectShape(elSchema, root)) {
+                fixBooleanValues(
+                  item,
+                  elSchema,
+                  root,
+                  depth + 1
+                );
+              }
+            } else if (typeof item === "string") {
+              const elAccepted = getAcceptedTypes(elSchema, root);
+              if (elAccepted?.has("boolean") && !elAccepted.has("string")) {
+                const lower = item.toLowerCase();
+                if (lower === "true" || lower === "false") {
+                  debugLogger.debug(
+                    `coercion: ${key}[${i}] = ${JSON.stringify(item)} \u2192 ${lower === "true"} (accepted: ${[...elAccepted].join("|")})`
+                  );
+                  value[i] = lower === "true";
+                }
+              }
+            }
+          }
+        } else {
+          const itemsSchema = resolved?.["items"];
+          if (itemsSchema) {
+            const resolvedItems = resolvePropSchema(itemsSchema, root);
+            if (!resolvedItems) continue;
+            if (schemaHasObjectShape(resolvedItems, root)) {
+              for (const item of value) {
+                if (typeof item === "object" && item !== null && !Array.isArray(item)) {
+                  fixBooleanValues(
+                    item,
+                    resolvedItems,
+                    root,
+                    depth + 1
+                  );
+                }
+              }
+            } else {
+              const itemsAccepted = getAcceptedTypes(resolvedItems, root);
+              if (itemsAccepted?.has("boolean") && !itemsAccepted.has("string")) {
+                for (let i = 0; i < value.length; i++) {
+                  const item = value[i];
+                  if (typeof item === "string") {
+                    const lower = item.toLowerCase();
+                    if (lower === "true" || lower === "false") {
+                      debugLogger.debug(
+                        `coercion: ${key}[${i}] = ${JSON.stringify(item)} \u2192 ${lower === "true"} (accepted: ${[...itemsAccepted].join("|")})`
+                      );
+                      value[i] = lower === "true";
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      } else {
+        if (resolved && schemaHasObjectShape(resolved, root)) {
+          fixBooleanValues(
+            value,
+            resolved,
+            root,
+            depth + 1
+          );
+        }
+      }
       continue;
     }
-    if (typeof value !== "string") continue;
-    const accepted = childSchema ? getAcceptedTypes(childSchema) : null;
-    if (!accepted || accepted.has("string") || !accepted.has("boolean")) {
+    if (typeof value === "string") {
+      const lower = value.toLowerCase();
+      if (lower !== "true" && lower !== "false") continue;
+      const accepted = resolved ? getAcceptedTypes(resolved, root) : null;
+      if (accepted?.has("boolean") && !accepted.has("string")) {
+        debugLogger.debug(
+          `coercion: ${key} = ${JSON.stringify(value)} \u2192 ${lower === "true"} (accepted: ${[...accepted].join("|")})`
+        );
+        data[key] = lower === "true";
+      }
+    }
+  }
+}
+__name(fixBooleanValues, "fixBooleanValues");
+function fixStringValues(data, schema, rootSchema, depth = 0) {
+  if (depth > 64) return;
+  const root = rootSchema ?? schema;
+  const properties = getEffectiveProperties(schema, root);
+  if (!properties && !schema["additionalProperties"]) return;
+  for (const key of Object.keys(data)) {
+    const value = data[key];
+    const additionalProps = schema["additionalProperties"];
+    const propSchema = properties?.[key] ?? (typeof additionalProps === "object" && additionalProps !== null ? additionalProps : void 0);
+    if (!propSchema) continue;
+    const resolved = resolvePropSchema(
+      propSchema,
+      root
+    );
+    if (!resolved) continue;
+    if (typeof value === "object" && value !== null) {
+      if (Array.isArray(value)) {
+        if (Array.isArray(resolved["prefixItems"])) {
+          let coerced;
+          for (let i = 0; i < value.length; i++) {
+            const elSchema = resolveArrayElementSchema(resolved, root, i);
+            if (!elSchema) continue;
+            const item = value[i];
+            if (typeof item === "object" && item !== null && !Array.isArray(item)) {
+              if (schemaHasObjectShape(elSchema, root)) {
+                fixStringValues(
+                  item,
+                  elSchema,
+                  root,
+                  depth + 1
+                );
+              }
+            } else if (item !== null && item !== void 0 && (typeof item === "number" || typeof item === "boolean" || typeof item === "bigint")) {
+              const elAccepted = getAcceptedTypes(elSchema, root);
+              if (elAccepted?.has("string")) {
+                const currentType = valueToSchemaType(item);
+                if (currentType && !typeIsAccepted(currentType, elAccepted)) {
+                  coerced ??= [...value];
+                  debugLogger.debug(
+                    `coercion: ${key}[${i}] = ${String(item)} \u2192 ${JSON.stringify(String(item))} (accepted: ${[...elAccepted].join("|")})`
+                  );
+                  coerced[i] = String(item);
+                }
+              }
+            }
+          }
+          if (coerced) data[key] = coerced;
+        } else {
+          const itemsSchema = resolved["items"];
+          if (itemsSchema) {
+            const resolvedItems = resolvePropSchema(itemsSchema, root);
+            if (resolvedItems) {
+              if (schemaHasObjectShape(resolvedItems, root)) {
+                for (const item of value) {
+                  if (typeof item === "object" && item !== null && !Array.isArray(item)) {
+                    fixStringValues(
+                      item,
+                      resolvedItems,
+                      root,
+                      depth + 1
+                    );
+                  }
+                }
+              } else {
+                const itemsAccepted = getAcceptedTypes(resolvedItems, root);
+                if (itemsAccepted?.has("string")) {
+                  let coerced;
+                  for (let i = 0; i < value.length; i++) {
+                    const item = value[i];
+                    if (item !== null && item !== void 0 && (typeof item === "number" || typeof item === "boolean" || typeof item === "bigint")) {
+                      const currentType = valueToSchemaType(item);
+                      if (currentType && !typeIsAccepted(currentType, itemsAccepted)) {
+                        coerced ??= [...value];
+                        debugLogger.debug(
+                          `coercion: ${key}[${i}] = ${String(item)} \u2192 ${JSON.stringify(String(item))} (accepted: ${[...itemsAccepted].join("|")})`
+                        );
+                        coerced[i] = String(item);
+                      }
+                    }
+                  }
+                  if (coerced) data[key] = coerced;
+                }
+              }
+            }
+          }
+        }
+      } else {
+        if (schemaHasObjectShape(resolved, root)) {
+          fixStringValues(
+            value,
+            resolved,
+            root,
+            depth + 1
+          );
+        }
+      }
       continue;
     }
-    const lower = value.toLowerCase();
-    if (lower === "true") {
-      data[key] = true;
-    } else if (lower === "false") {
-      data[key] = false;
+    if (typeof value === "number" || typeof value === "boolean" || typeof value === "bigint") {
+      const accepted = getAcceptedTypes(resolved, root);
+      if (accepted?.has("string")) {
+        const currentType = valueToSchemaType(value);
+        if (currentType && !typeIsAccepted(currentType, accepted)) {
+          debugLogger.debug(
+            `coercion: ${key} = ${String(value)} \u2192 ${JSON.stringify(String(value))} (accepted: ${[...accepted].join("|")})`
+          );
+          data[key] = String(value);
+        }
+      }
     }
   }
 }
-__name(fixBooleanValues, "fixBooleanValues");
+__name(fixStringValues, "fixStringValues");
 
 // packages/core/src/agents/runtime/agent-statistics.ts
 init_esbuild_shims();
@@ -14801,7 +15318,7 @@ function isTool(obj) {
 }
 __name(isTool, "isTool");
 function hasCycleInSchema(schema) {
-  function resolveRef(ref) {
+  function resolveRef2(ref) {
     if (!ref.startsWith("#/")) {
       return null;
     }
@@ -14815,7 +15332,7 @@ function hasCycleInSchema(schema) {
     }
     return current;
   }
-  __name(resolveRef, "resolveRef");
+  __name(resolveRef2, "resolveRef");
   function traverse(node, visitedRefs, pathRefs) {
     if (typeof node !== "object" || node === null) {
       return false;
@@ -14836,7 +15353,7 @@ function hasCycleInSchema(schema) {
       if (visitedRefs.has(ref)) {
         return false;
       }
-      const resolvedNode = resolveRef(ref);
+      const resolvedNode = resolveRef2(ref);
       if (resolvedNode) {
         visitedRefs.add(ref);
         pathRefs.add(ref);