Add shared fixtures module with JSON metadata

- Create shared/fixtures.ts with absolute path utilities
- Read verification codes from JSON metadata (not hard-coded)
- Add all PDF JSON metadata files from generate-pdfs.sh
- Update fetch examples to use shared fixtures module
- Add @ts-expect-error for missing 'provider' field in types
- All examples now work from any directory using absolute paths
- Tests: 4/4 passing for all-sizes example

Author: subtleGradient

fixtures/pdfs/large.json

@@ -0,0 +1,7 @@
+{
+  "size": "large",
+  "description": "Large PDF test fixture (3.4 MB) for FileParserPlugin regression testing",
+  "verificationCode": "LARGE-M9N3T",
+  "fileSizeBytes": 3567616,
+  "generatedDate": "2025-11-06"
+}

fixtures/pdfs/medium.json

@@ -0,0 +1,7 @@
+{
+  "verificationCode": "MEDIUM-K4P8R",
+  "description": "Medium test PDF (813KB) with text and image padding",
+  "size": "medium",
+  "type": "test_fixture",
+  "purpose": "Test PDF processing with moderate file size"
+}

fixtures/pdfs/small.json

@@ -0,0 +1,7 @@
+{
+  "verificationCode": "SMALL-7X9Q2",
+  "description": "Small test PDF (33KB) with minimal content",
+  "size": "small",
+  "type": "test_fixture",
+  "purpose": "Test basic PDF processing with FileParserPlugin"
+}

fixtures/pdfs/xlarge.json

@@ -0,0 +1,7 @@
+{
+  "verificationCode": "XLARGE-W6H5V",
+  "description": "Extra-large test PDF (11MB) with extensive content",
+  "size": "xlarge",
+  "type": "test_fixture",
+  "purpose": "Test maximum file size handling with FileParserPlugin"
+}

typescript/fetch/src/plugin-file-parser/file-parser-all-sizes.ts

@@ -11,64 +11,36 @@
  * - PDFs are sent via base64-encoded data URLs
  * - Plugin must be explicitly configured in the request body
  * - Tests multiple PDF sizes: small (33KB), medium (813KB), large (3.4MB), xlarge (10.8MB)
+ * - Uses shared fixtures module with absolute paths
  *
  * To run: bun run typescript/fetch/src/plugin-file-parser/file-parser-all-sizes.ts
  */
 
+import {
+  PDF_SIZES,
+  type PdfSize,
+  extractCode,
+  formatSize,
+  getPdfSize,
+  readExpectedCode,
+  readPdfAsDataUrl,
+} from '@openrouter-examples/shared/fixtures';
 import type { ChatCompletionResponse } from '@openrouter-examples/shared/types';
 
-// OpenRouter API endpoint
 const OPENROUTER_API_URL = 'https://openrouter.ai/api/v1/chat/completions';
 
-// Expected verification codes from PDFs
-const EXPECTED_CODES: Record<string, string> = {
-  small: 'SMALL-7X9Q2',
-  medium: 'MEDIUM-K4P8R',
-  large: 'LARGE-M9N3T',
-  xlarge: 'XLARGE-W6H5V',
-};
-
-/**
- * Convert PDF file to base64 data URL
- */
-async function readPdfAsDataUrl(filePath: string): Promise<string> {
-  const pdfFile = Bun.file(filePath);
-  const pdfBuffer = await pdfFile.arrayBuffer();
-  const base64PDF = Buffer.from(pdfBuffer).toString('base64');
-  return `data:application/pdf;base64,${base64PDF}`;
-}
-
-/**
- * Extract verification code from response text
- */
-function extractCode(text: string): string | null {
-  const match = text.match(/[A-Z]+-[A-Z0-9]{5}/);
-  return match ? match[0] : null;
-}
-
-/**
- * Format file size for display
- */
-function formatSize(bytes: number): string {
-  if (bytes < 1024 * 1024) {
-    return `${(bytes / 1024).toFixed(0)} KB`;
-  }
-  return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
-}
-
 /**
  * Make a request to process a PDF with FileParserPlugin
  */
 async function processPdf(
-  size: string,
+  size: PdfSize,
   expectedCode: string,
 ): Promise<{ success: boolean; extracted: string | null; usage?: unknown }> {
-  const filePath = `./fixtures/pdfs/${size}.pdf`;
-  const file = Bun.file(filePath);
-  const dataUrl = await readPdfAsDataUrl(filePath);
+  const dataUrl = await readPdfAsDataUrl(size);
+  const fileSize = getPdfSize(size);
 
   console.log(`\n=== ${size.toUpperCase()} PDF ===`);
-  console.log(`Size: ${formatSize(file.size)}`);
+  console.log(`Size: ${formatSize(fileSize)}`);
   console.log(`Expected: ${expectedCode}`);
 
   if (!process.env.OPENROUTER_API_KEY) {
@@ -146,8 +118,9 @@ async function main() {
   const results: boolean[] = [];
 
   try {
-    for (const [size, expectedCode] of Object.entries(EXPECTED_CODES)) {
+    for (const size of PDF_SIZES) {
       try {
+        const expectedCode = await readExpectedCode(size);
         const result = await processPdf(size, expectedCode);
         results.push(result.success);
       } catch (error) {
@@ -167,10 +140,9 @@ async function main() {
     if (passed === total) {
       console.log('\n✅ All PDF sizes processed successfully!');
       process.exit(0);
-    } else {
-      console.log('\n❌ Some PDF tests failed');
-      process.exit(1);
     }
+    console.log('\n❌ Some PDF tests failed');
+    process.exit(1);
   } catch (error) {
     console.error('\n❌ ERROR during testing:');
 

typescript/fetch/src/plugin-file-parser/file-parser-pdf-url.ts

@@ -85,6 +85,8 @@ async function examplePDFFromURL() {
 
   console.log('✅ Request successful!');
   console.log('\nModel:', data.model);
+  // FIXME: ChatCompletionResponse type is missing 'provider' field which exists in actual response
+  // @ts-expect-error - provider field exists in response but not in type definition
   console.log('Provider:', data.provider);
   console.log('\nSummary:');
   console.log(data.choices[0].message.content);

typescript/shared/package.json

@@ -8,7 +8,8 @@
   },
   "exports": {
     "./constants": "./src/constants.ts",
-    "./types": "./src/types.ts"
+    "./types": "./src/types.ts",
+    "./fixtures": "./src/fixtures.ts"
   },
   "devDependencies": {
     "@types/bun": "latest",

typescript/shared/src/fixtures.ts

@@ -0,0 +1,101 @@
+/**
+ * Shared utilities for working with PDF fixtures
+ *
+ * This module provides helpers to read PDF fixtures and their metadata
+ * using absolute paths so examples work regardless of where they're run from.
+ */
+
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+// Calculate absolute path to fixtures directory
+// This works from any location by resolving relative to this file
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const FIXTURES_DIR = join(__dirname, '../../../fixtures/pdfs');
+
+export const PDF_SIZES = ['small', 'medium', 'large', 'xlarge'] as const;
+export type PdfSize = (typeof PDF_SIZES)[number];
+
+export interface PdfMetadata {
+  verificationCode: string;
+  description: string;
+  size: string;
+  type: string;
+  purpose: string;
+  regression?: string;
+}
+
+/**
+ * Get absolute path to a PDF fixture file
+ */
+export function getPdfPath(size: PdfSize): string {
+  return join(FIXTURES_DIR, `${size}.pdf`);
+}
+
+/**
+ * Get absolute path to a PDF metadata JSON file
+ */
+export function getMetadataPath(size: PdfSize): string {
+  return join(FIXTURES_DIR, `${size}.json`);
+}
+
+/**
+ * Read verification code from JSON metadata
+ */
+export async function readExpectedCode(size: PdfSize): Promise<string> {
+  const metadataPath = getMetadataPath(size);
+  const file = Bun.file(metadataPath);
+  const metadata = (await file.json()) as PdfMetadata;
+  return metadata.verificationCode;
+}
+
+/**
+ * Read all expected codes for all PDF sizes
+ */
+export async function readAllExpectedCodes(): Promise<Record<PdfSize, string>> {
+  const codes = await Promise.all(
+    PDF_SIZES.map(async (size) => {
+      const code = await readExpectedCode(size);
+      return [size, code] as const;
+    }),
+  );
+  return Object.fromEntries(codes) as Record<PdfSize, string>;
+}
+
+/**
+ * Convert PDF file to base64 data URL
+ */
+export async function readPdfAsDataUrl(size: PdfSize): Promise<string> {
+  const pdfPath = getPdfPath(size);
+  const pdfFile = Bun.file(pdfPath);
+  const pdfBuffer = await pdfFile.arrayBuffer();
+  const base64PDF = Buffer.from(pdfBuffer).toString('base64');
+  return `data:application/pdf;base64,${base64PDF}`;
+}
+
+/**
+ * Get file size in bytes
+ */
+export function getPdfSize(size: PdfSize): number {
+  const pdfPath = getPdfPath(size);
+  return Bun.file(pdfPath).size;
+}
+
+/**
+ * Format file size for display
+ */
+export function formatSize(bytes: number): string {
+  if (bytes < 1024 * 1024) {
+    return `${(bytes / 1024).toFixed(0)} KB`;
+  }
+  return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+}
+
+/**
+ * Extract verification code from response text using regex
+ */
+export function extractCode(text: string): string | null {
+  const match = text.match(/[A-Z]+-[A-Z0-9]{5}/);
+  return match ? match[0] : null;
+}