fix(chunk): assign list-typed conversion options directly instead of JSON.stringify

ChunkService.buildFormFields JSON-stringified `from_formats`, `ocr_lang`,
and `page_range` into single multipart form-field values. docling-serve
expects these as repeated multi-value fields, so requests setting any of
them are rejected with HTTP 422 by Pydantic.

Mirror the file.ts:508 pattern: widen the (private) return type to
Record<string, unknown> and assign the arrays directly. The platform
multipart encoder (platform/http.ts) already iterates arrays and coerces
each element via String(item), so numeric tuples like page_range
serialize correctly without explicit help.

Adds a vitest case asserting the three fields pass through to
streamUpload as arrays, not JSON strings.

Author: tonythomson

src/services/chunk.ts

@@ -416,14 +416,14 @@ export class ChunkService {
   private buildFormFields(
     options: ConversionOptions,
     targetType: "inbody" | "zip"
-  ): Record<string, string> {
-    const fields: Record<string, string> = {
+  ): Record<string, unknown> {
+    const fields: Record<string, unknown> = {
       target_type: targetType,
     };
 
     // Add conversion options
     if (options.from_formats) {
-      fields.convert_from_formats = JSON.stringify(options.from_formats);
+      fields.convert_from_formats = options.from_formats;
     }
     if (options.image_export_mode) {
       fields.convert_image_export_mode = options.image_export_mode;
@@ -438,7 +438,7 @@ export class ChunkService {
       fields.convert_ocr_engine = options.ocr_engine;
     }
     if (options.ocr_lang) {
-      fields.convert_ocr_lang = JSON.stringify(options.ocr_lang);
+      fields.convert_ocr_lang = options.ocr_lang;
     }
     if (options.pdf_backend) {
       fields.convert_pdf_backend = options.pdf_backend;
@@ -453,7 +453,7 @@ export class ChunkService {
       fields.convert_pipeline = options.pipeline;
     }
     if (options.page_range) {
-      fields.convert_page_range = JSON.stringify(options.page_range);
+      fields.convert_page_range = options.page_range;
     }
     if (options.document_timeout !== undefined) {
       fields.convert_document_timeout = String(options.document_timeout);

tests/unit/chunk-service.test.ts

@@ -0,0 +1,70 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { ChunkService } from "../../src/services/chunk";
+import { HttpClient } from "../../src/api";
+import type {
+  ApiClientConfig,
+  ChunkDocumentResponse,
+} from "../../src/types/api";
+
+const mockConfig: ApiClientConfig = {
+  baseUrl: "http://localhost:5001",
+  timeout: 30000,
+};
+
+const capturedFields: Array<Record<string, unknown>> = [];
+
+vi.mock("../../src/api/http", async (importOriginal) => {
+  const mod: any = await importOriginal();
+  return {
+    HttpClient: class extends mod.HttpClient {
+      async streamUpload(
+        _endpoint: string,
+        _files: any,
+        fields: Record<string, unknown>
+      ) {
+        capturedFields.push(fields);
+        return {
+          data: {
+            documents: [],
+            chunks: [],
+            processing_time: 1,
+          } satisfies ChunkDocumentResponse,
+          status: 200,
+          statusText: "OK",
+          headers: { "content-type": "application/json" },
+        };
+      }
+    },
+  };
+});
+
+describe("ChunkService.buildFormFields", () => {
+  let http: HttpClient;
+  let service: ChunkService;
+
+  beforeEach(() => {
+    capturedFields.length = 0;
+    http = new HttpClient(mockConfig);
+    service = new ChunkService(http);
+  });
+
+  it("passes list-typed conversion options as arrays (not JSON strings) to streamUpload", async () => {
+    await service.chunkHybridSync(Buffer.from("pdf"), "example.pdf", {
+      from_formats: ["pdf", "docx"],
+      ocr_lang: ["en", "fr"],
+      page_range: [1, 2],
+    });
+
+    expect(capturedFields).toHaveLength(1);
+    const fields = capturedFields[0];
+
+    expect(fields.convert_from_formats).toEqual(["pdf", "docx"]);
+    expect(fields.convert_ocr_lang).toEqual(["en", "fr"]);
+    expect(fields.convert_page_range).toEqual([1, 2]);
+
+    // Guard against regression to JSON.stringify.
+    expect(typeof fields.convert_from_formats).not.toBe("string");
+    expect(typeof fields.convert_ocr_lang).not.toBe("string");
+    expect(typeof fields.convert_page_range).not.toBe("string");
+  });
+});