Merge pull request #1 from PSPDFKit-labs/fix/html-input-conversion

fix: normalize nutrient_extract_text language schema for OpenClaw

Author: jdrhyne

src/files.ts

@@ -115,7 +115,9 @@ export function buildFormData(
 
   for (const [key, ref] of fileRefs.entries()) {
     if (ref.file) {
-      const blob = new Blob([new Uint8Array(ref.file.buffer)]);
+      const blob = ref.mimeType
+        ? new Blob([new Uint8Array(ref.file.buffer)], { type: ref.mimeType })
+        : new Blob([new Uint8Array(ref.file.buffer)]);
       formData.append(key, blob, ref.name);
     }
   }

src/tools/convert-to-pdf.ts

@@ -13,6 +13,18 @@ import {
   deriveOutputPath,
 } from '../files.js';
 
+function isHtmlInput(filePath: string): boolean {
+  if (filePath.startsWith('http://') || filePath.startsWith('https://')) {
+    try {
+      return /\.html?$/i.test(new URL(filePath).pathname);
+    } catch {
+      return /\.html?$/i.test(filePath);
+    }
+  }
+
+  return /\.html?$/i.test(filePath);
+}
+
 export const convertToPdfTool: ToolDefinition = {
   name: 'nutrient_convert_to_pdf',
   description:
@@ -74,12 +86,20 @@ export const convertToPdfTool: ToolDefinition = {
       const outputPath = args.outputPath || deriveOutputPath(args.filePath, 'pdf');
       assertOutputDiffersFromInput(args.filePath, outputPath, ctx.sandboxDir);
 
+      const inputIsHtml = isHtmlInput(args.filePath);
       const fileRef = readFileReference(args.filePath, ctx.sandboxDir);
-      const fileRefs = new Map<string, FileReference>([[fileRef.key, fileRef]]);
+      const fileRefs = new Map<string, FileReference>([
+        [
+          fileRef.key,
+          inputIsHtml && fileRef.file
+            ? { ...fileRef, mimeType: 'text/html' }
+            : fileRef,
+        ],
+      ]);
 
       // Build the part entry
       const part: Record<string, unknown> = {
-        file: fileRef.url ?? fileRef.key,
+        [inputIsHtml ? 'html' : 'file']: fileRef.url ?? fileRef.key,
       };
       if (args.password) part.password = args.password;
       if (args.pages) part.pages = args.pages;

src/tools/extract-text.ts

@@ -42,29 +42,36 @@ export const nutrient_extract_text: ToolDefinition = {
           "'key-values' for detected key-value pairs (phone numbers, emails, dates, etc.)",
       },
       language: {
-        type: ['string', 'array'],
+        type: 'string',
         description:
           "OCR language(s) for text extraction (default: 'english'). " +
-          'Can be a single language string or an array of languages.',
+          "Use a single language or a comma-separated list (for example: 'english,german').",
         default: 'english',
       },
     },
   },
 
   async execute(
-    args: { filePath: string; mode?: ExtractionMode; language?: string | string[] },
+    args: { filePath: string; mode?: ExtractionMode; language?: string },
     ctx: ToolContext,
   ): Promise<ToolResponse> {
     try {
       const { filePath, mode = 'text', language = 'english' } = args;
+      const normalizedLanguage =
+        typeof language === 'string' && language.includes(',')
+          ? language
+              .split(',')
+              .map((s) => s.trim())
+              .filter(Boolean)
+          : language;
 
       const fileRef = readFileReference(filePath, ctx.sandboxDir);
       const fileRefs = new Map([[fileRef.key, fileRef]]);
 
       const output: Record<string, unknown> = {
         type: 'json-content',
         [MODE_FLAGS[mode]]: true,
-        language,
+        language: normalizedLanguage,
       };
 
       const instructions = {

src/types.ts

@@ -90,6 +90,7 @@ export interface FileReference {
     buffer: Buffer;
     path: string;
   };
+  mimeType?: string;
   url?: string;
   name: string;
 }

test/tools/convert-to-pdf.test.ts

@@ -6,6 +6,22 @@ import type { ToolContext } from '../../src/types.js';
 import fs from 'node:fs';
 import path from 'node:path';
 
+function getBuildBody(ctx: ToolContext): FormData | Record<string, unknown> {
+  const call = (ctx.client.post as any).mock.calls.at(-1);
+  expect(call[0]).toBe('build');
+  return call[1];
+}
+
+function getInstructions(body: FormData | Record<string, unknown>): Record<string, any> {
+  if (body instanceof FormData) {
+    const instructionsRaw = body.get('instructions');
+    expect(typeof instructionsRaw).toBe('string');
+    return JSON.parse(instructionsRaw as string);
+  }
+
+  return body as Record<string, any>;
+}
+
 describe('nutrient_convert_to_pdf', () => {
   let ctx: ToolContext;
 
@@ -26,7 +42,10 @@ describe('nutrient_convert_to_pdf', () => {
     );
     expect(result.success).toBe(true);
     expect(result.output).toContain('output.pdf');
-    expect(ctx.client.post).toHaveBeenCalledWith('build', expect.anything());
+    const body = getBuildBody(ctx);
+    const instructions = getInstructions(body);
+    expect(instructions.parts[0].file).toBeTruthy();
+    expect(instructions.parts[0].html).toBeUndefined();
     expect(fs.existsSync(path.join(ctx.sandboxDir!, 'output.pdf'))).toBe(true);
   });
 
@@ -41,8 +60,8 @@ describe('nutrient_convert_to_pdf', () => {
     expect(call[0]).toBe('build');
   });
 
-  it('forwards HTML layout options', async () => {
-    writeSandboxFile(ctx.sandboxDir!, 'page.html');
+  it('uses part.html for local HTML and keeps htmlLayout on part.layout', async () => {
+    writeSandboxFile(ctx.sandboxDir!, 'page.html', '<html><body>test</body></html>');
     await convertToPdfTool.execute(
       {
         filePath: 'page.html',
@@ -51,7 +70,35 @@ describe('nutrient_convert_to_pdf', () => {
       },
       ctx,
     );
-    expect(ctx.client.post).toHaveBeenCalled();
+
+    const body = getBuildBody(ctx);
+    expect(body).toBeInstanceOf(FormData);
+
+    const instructions = getInstructions(body);
+    expect(instructions.parts[0].html).toBeTruthy();
+    expect(instructions.parts[0].file).toBeUndefined();
+    expect(instructions.parts[0].layout).toEqual({ orientation: 'landscape', size: 'A4' });
+
+    const htmlPart = (body as FormData).get(instructions.parts[0].html);
+    expect(htmlPart).toBeTruthy();
+    expect(typeof htmlPart).not.toBe('string');
+    if (htmlPart && typeof htmlPart !== 'string') {
+      expect(htmlPart.type).toBe('text/html');
+    }
+  });
+
+  it('uses part.html for HTML URLs', async () => {
+    const htmlUrl = 'https://example.com/page.html?utm=test';
+    await convertToPdfTool.execute(
+      { filePath: htmlUrl, outputPath: 'out.pdf' },
+      ctx,
+    );
+
+    const body = getBuildBody(ctx);
+    expect(body).not.toBeInstanceOf(FormData);
+    const instructions = getInstructions(body);
+    expect(instructions.parts[0].html).toBe(htmlUrl);
+    expect(instructions.parts[0].file).toBeUndefined();
   });
 
   it('forwards page ranges', async () => {