@struktur/sdk 2.1.2 → 2.2.0

package/dist/index.js

@@ -0,0 +1,4111 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/parsers/collect.ts
+async function collectStream(stream) {
+  const reader = stream.getReader();
+  const chunks = [];
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) {
+        break;
+      }
+      chunks.push(value);
+    }
+  } finally {
+    reader.releaseLock();
+  }
+  const totalLength = chunks.reduce((sum, chunk) => sum + chunk.length, 0);
+  const result = new Uint8Array(totalLength);
+  let offset = 0;
+  for (const chunk of chunks) {
+    result.set(chunk, offset);
+    offset += chunk.length;
+  }
+  return Buffer.from(result);
+}
+var init_collect = __esm({
+  "src/parsers/collect.ts"() {
+    "use strict";
+  }
+});
+
+// src/parsers/pdf.ts
+var pdf_exports = {};
+__export(pdf_exports, {
+  parsePdf: () => parsePdf
+});
+async function parsePdf(input, options) {
+  const buffer = Buffer.isBuffer(input) ? input : await collectStream(input);
+  const { PDFParse } = await import("pdf-parse");
+  const parser = new PDFParse({ data: buffer });
+  const textResult = await parser.getText();
+  const pageTextMap = /* @__PURE__ */ new Map();
+  if (textResult.pages.length > 0) {
+    for (const page of textResult.pages) {
+      if (page.text && page.text.trim().length > 0) {
+        pageTextMap.set(page.num, page.text);
+      }
+    }
+  }
+  let imageResult;
+  if (options?.includeImages !== false) {
+    try {
+      imageResult = await parser.getImage({ imageBuffer: false, imageDataUrl: true });
+    } catch {
+    }
+  }
+  let screenshotResult;
+  if (options?.screenshots === true) {
+    try {
+      const screenshotParams = { imageBuffer: false, imageDataUrl: true };
+      if (options.screenshotWidth !== void 0) {
+        screenshotParams.desiredWidth = options.screenshotWidth;
+      } else {
+        screenshotParams.scale = options.screenshotScale ?? 1.5;
+      }
+      screenshotResult = await parser.getScreenshot(screenshotParams);
+    } catch {
+    }
+  }
+  const pageImageMap = /* @__PURE__ */ new Map();
+  if (imageResult) {
+    for (const pageImages of imageResult.pages) {
+      const artifactImages = pageImages.images.filter((img) => img.dataUrl).map((img) => {
+        const base64 = img.dataUrl.replace(/^data:[^;]+;base64,/, "");
+        const artifactImage = {
+          type: "image",
+          base64,
+          width: img.width,
+          height: img.height,
+          imageType: "embedded"
+        };
+        return artifactImage;
+      });
+      if (artifactImages.length > 0) {
+        pageImageMap.set(pageImages.pageNumber, artifactImages);
+      }
+    }
+  }
+  if (screenshotResult) {
+    for (const screenshot of screenshotResult.pages) {
+      if (screenshot.dataUrl) {
+        const base64 = screenshot.dataUrl.replace(/^data:[^;]+;base64,/, "");
+        const artifactImage = {
+          type: "image",
+          base64,
+          width: screenshot.width,
+          height: screenshot.height,
+          imageType: "screenshot"
+        };
+        const existing = pageImageMap.get(screenshot.pageNumber) ?? [];
+        pageImageMap.set(screenshot.pageNumber, [...existing, artifactImage]);
+      }
+    }
+  }
+  let contents;
+  if (textResult.pages.length > 0) {
+    const allPageNums = /* @__PURE__ */ new Set([
+      ...pageTextMap.keys(),
+      ...pageImageMap.keys()
+    ]);
+    contents = Array.from(allPageNums).sort((a, b) => a - b).map((pageNum) => {
+      const entry = { page: pageNum };
+      const text = pageTextMap.get(pageNum);
+      if (text) entry.text = text;
+      const media = pageImageMap.get(pageNum);
+      if (media) entry.media = media;
+      return entry;
+    });
+  } else {
+    const entry = { text: textResult.text };
+    const firstPageImages = pageImageMap.size > 0 ? pageImageMap.values().next().value : void 0;
+    if (firstPageImages) entry.media = firstPageImages;
+    contents = [entry];
+  }
+  if (contents.length === 0) {
+    contents = [{ text: "" }];
+  }
+  let infoResult;
+  try {
+    infoResult = await parser.getInfo();
+  } catch {
+  }
+  await parser.destroy();
+  return {
+    id: `artifact-${crypto.randomUUID()}`,
+    type: "pdf",
+    raw: async () => buffer,
+    contents,
+    metadata: infoResult ? {
+      numpages: textResult.total,
+      info: infoResult
+    } : { numpages: textResult.total }
+  };
+}
+var init_pdf = __esm({
+  "src/parsers/pdf.ts"() {
+    "use strict";
+    init_collect();
+  }
+});
+
+// src/fields.ts
+var SCALAR_TYPES = /* @__PURE__ */ new Set([
+  "string",
+  "number",
+  "boolean",
+  "integer",
+  "int"
+]);
+var SCALAR_ALIASES = {
+  bool: "boolean",
+  float: "number"
+  // Note: "int" stays as "int" (not aliased to "integer") so the schema
+  // builder can emit the extra multipleOf:1 constraint.
+};
+var extractBraces = (rawType, prefix) => {
+  if (!rawType.startsWith(prefix + "{") || !rawType.endsWith("}")) {
+    return null;
+  }
+  return rawType.slice(prefix.length + 1, -1);
+};
+var parseScalarType = (raw, fieldName) => {
+  const resolved = SCALAR_ALIASES[raw] ?? raw;
+  if (!SCALAR_TYPES.has(resolved)) {
+    const allNames = [...Object.keys(SCALAR_ALIASES), ...SCALAR_TYPES].sort();
+    throw new Error(
+      `Unknown type "${raw}" for field "${fieldName}". Scalar types: ${allNames.join(", ")}. Complex types: enum{a|b|c}, array{string}, or array (shorthand for array{string}).`
+    );
+  }
+  return resolved;
+};
+var parseField = (token) => {
+  const colonIndex = token.indexOf(":");
+  if (colonIndex === -1) {
+    const name2 = token.trim();
+    if (!name2) throw new Error("Empty field name in fields string.");
+    return { name: name2, kind: "scalar", type: "string" };
+  }
+  const name = token.slice(0, colonIndex).trim();
+  const rawType = token.slice(colonIndex + 1).trim();
+  if (!name) {
+    throw new Error(`Empty field name before colon in token: "${token}".`);
+  }
+  if (!rawType) {
+    throw new Error(
+      `Empty type after colon for field "${name}". Omit the colon or specify a type.`
+    );
+  }
+  const enumContent = extractBraces(rawType, "enum");
+  if (enumContent !== null) {
+    const values = enumContent.split("|").map((v) => v.trim()).filter(Boolean);
+    if (values.length < 2) {
+      throw new Error(
+        `enum for field "${name}" must have at least two values separated by "|", got: "${enumContent}".`
+      );
+    }
+    return { name, kind: "enum", values };
+  }
+  const arrayContent = extractBraces(rawType, "array");
+  if (arrayContent !== null) {
+    const itemType = arrayContent.trim();
+    if (!itemType) {
+      throw new Error(
+        `array for field "${name}" requires an item type, e.g. array{string}.`
+      );
+    }
+    return { name, kind: "array", items: parseScalarType(itemType, name) };
+  }
+  if (rawType === "array") {
+    return { name, kind: "array", items: "string" };
+  }
+  return { name, kind: "scalar", type: parseScalarType(rawType, name) };
+};
+var parseFieldsString = (fields) => {
+  if (!fields.trim()) {
+    throw new Error("Fields string must not be empty.");
+  }
+  const tokens = [];
+  let depth = 0;
+  let current = "";
+  for (const ch of fields) {
+    if (ch === "{") {
+      depth++;
+      current += ch;
+    } else if (ch === "}") {
+      depth--;
+      current += ch;
+    } else if (ch === "," && depth === 0) {
+      tokens.push(current);
+      current = "";
+    } else {
+      current += ch;
+    }
+  }
+  if (current) tokens.push(current);
+  if (depth !== 0) {
+    throw new Error("Unmatched braces in fields string.");
+  }
+  return tokens.map((token) => parseField(token));
+};
+var buildSchemaFromParsedFields = (fields) => {
+  if (fields.length === 0) {
+    throw new Error("Cannot build a schema from an empty fields list.");
+  }
+  const properties = {};
+  const required = [];
+  for (const field of fields) {
+    if (field.kind === "scalar") {
+      properties[field.name] = field.type === "int" ? { type: "integer", multipleOf: 1 } : { type: field.type };
+    } else if (field.kind === "enum") {
+      properties[field.name] = { type: "string", enum: field.values };
+    } else {
+      properties[field.name] = { type: "array", items: field.items === "int" ? { type: "integer", multipleOf: 1 } : { type: field.items } };
+    }
+    required.push(field.name);
+  }
+  return {
+    type: "object",
+    properties,
+    required,
+    additionalProperties: false
+  };
+};
+var buildSchemaFromFields = (fields) => buildSchemaFromParsedFields(parseFieldsString(fields));
+
+// src/extract.ts
+var emptyUsage = { inputTokens: 0, outputTokens: 0, totalTokens: 0 };
+var safeShutdown = async (telemetry) => {
+  if (!telemetry) return;
+  try {
+    await telemetry.shutdown();
+  } catch {
+  }
+};
+var safeEndSpan = (telemetry, span, result) => {
+  if (!telemetry || !span) return;
+  try {
+    telemetry.endSpan(span, result);
+  } catch {
+  }
+};
+var resolveSchema = (options) => {
+  const hasSchema = options.schema !== void 0;
+  const hasFields = options.fields !== void 0;
+  if (hasSchema && hasFields) {
+    throw new Error(
+      "Provide either `schema` or `fields`, not both. They are mutually exclusive."
+    );
+  }
+  if (!hasSchema && !hasFields) {
+    throw new Error(
+      "A schema definition is required. Provide `schema` (a JSON Schema object) or `fields` (a shorthand fields string)."
+    );
+  }
+  if (hasFields) {
+    return buildSchemaFromFields(options.fields);
+  }
+  return options.schema;
+};
+var extract = async (options) => {
+  const debug = options.debug;
+  let telemetry = options.telemetry;
+  if (telemetry) {
+    try {
+      await telemetry.initialize();
+    } catch (error) {
+      console.error("Telemetry initialization failed, continuing without telemetry:", error.message);
+      telemetry = void 0;
+    }
+  }
+  const rootSpan = telemetry?.startSpan({
+    name: "struktur.extract",
+    kind: "CHAIN",
+    attributes: {
+      "extraction.strategy": options.strategy?.name ?? "default",
+      "extraction.artifacts.count": options.artifacts.length
+    }
+  });
+  try {
+    let resolvedOptions;
+    try {
+      const schema = resolveSchema(options);
+      resolvedOptions = { ...options, schema };
+    } catch (error) {
+      debug?.extractionComplete({
+        success: false,
+        totalInputTokens: 0,
+        totalOutputTokens: 0,
+        totalTokens: 0,
+        error: error.message
+      });
+      safeEndSpan(telemetry, rootSpan, {
+        status: "error",
+        error
+      });
+      await safeShutdown(telemetry);
+      return {
+        data: null,
+        usage: emptyUsage,
+        error
+      };
+    }
+    const total = resolvedOptions.strategy.getEstimatedSteps?.(resolvedOptions.artifacts);
+    debug?.strategyRunStart({
+      strategy: resolvedOptions.strategy.name,
+      estimatedSteps: total ?? 1,
+      artifactCount: resolvedOptions.artifacts.length
+    });
+    await resolvedOptions.events?.onStep?.({ step: 1, total, label: "start" });
+    debug?.step({
+      step: 1,
+      total,
+      label: "start",
+      strategy: resolvedOptions.strategy.name
+    });
+    const result = await resolvedOptions.strategy.run(resolvedOptions);
+    await resolvedOptions.events?.onStep?.({
+      step: total ?? 1,
+      total,
+      label: "complete"
+    });
+    debug?.step({
+      step: total ?? 1,
+      total,
+      label: "complete",
+      strategy: resolvedOptions.strategy.name
+    });
+    debug?.extractionComplete({
+      success: !result.error,
+      totalInputTokens: result.usage.inputTokens,
+      totalOutputTokens: result.usage.outputTokens,
+      totalTokens: result.usage.totalTokens,
+      error: result.error?.message
+    });
+    safeEndSpan(telemetry, rootSpan, {
+      status: result.error ? "error" : "ok",
+      output: result.data,
+      error: result.error
+    });
+    await safeShutdown(telemetry);
+    return result;
+  } catch (error) {
+    debug?.extractionComplete({
+      success: false,
+      totalInputTokens: 0,
+      totalOutputTokens: 0,
+      totalTokens: 0,
+      error: error.message
+    });
+    safeEndSpan(telemetry, rootSpan, {
+      status: "error",
+      error
+    });
+    await safeShutdown(telemetry);
+    return {
+      data: null,
+      usage: emptyUsage,
+      error
+    };
+  }
+};
+
+// src/artifacts/urlToArtifact.ts
+var urlToArtifact = async (url) => {
+  const response = await fetch(url);
+  if (!response.ok) {
+    throw new Error(`Failed to fetch artifact: ${response.status} ${response.statusText}`);
+  }
+  const data = await response.json();
+  return {
+    ...data,
+    raw: data.raw ?? (async () => Buffer.from(JSON.stringify(data.contents ?? [])))
+  };
+};
+
+// src/artifacts/providers.ts
+var defaultArtifactProviders = {};
+
+// src/artifacts/fileToArtifact.ts
+var bufferToTextArtifact = (buffer) => ({
+  id: `artifact-${crypto.randomUUID()}`,
+  type: "text",
+  raw: async () => buffer,
+  contents: [{ text: buffer.toString() }]
+});
+var bufferToImageArtifact = (buffer) => ({
+  id: `artifact-${crypto.randomUUID()}`,
+  type: "image",
+  raw: async () => buffer,
+  contents: [{ media: [{ type: "image", contents: buffer }] }]
+});
+var fileToArtifact = async (buffer, options) => {
+  const providers = options.providers ?? defaultArtifactProviders;
+  const provider = providers[options.mimeType];
+  if (provider) {
+    return provider(buffer);
+  }
+  if (options.mimeType.startsWith("text/")) {
+    return bufferToTextArtifact(buffer);
+  }
+  if (options.mimeType.startsWith("image/")) {
+    return bufferToImageArtifact(buffer);
+  }
+  throw new Error(
+    `No artifact provider registered for ${options.mimeType}`
+  );
+};
+
+// src/validation/validator.ts
+import Ajv from "ajv";
+import addFormats from "ajv-formats";
+var SchemaValidationError = class extends Error {
+  errors;
+  constructor(message, errors) {
+    super(message);
+    this.name = "SchemaValidationError";
+    this.errors = errors;
+  }
+};
+var ARTIFACT_ID_PATTERN = /^artifact:[^/]+\/images\/image\d+\.\w+$/;
+var createAjv = () => {
+  const ajv = new Ajv({
+    allErrors: true,
+    strict: false,
+    allowUnionTypes: true
+  });
+  addFormats(ajv);
+  ajv.addFormat("artifact-id", {
+    type: "string",
+    validate: (data) => ARTIFACT_ID_PATTERN.test(data)
+  });
+  return ajv;
+};
+var validateOrThrow = (ajv, schema, data) => {
+  const validate = ajv.compile(schema);
+  const valid = validate(data);
+  if (!valid) {
+    const errors = validate.errors ?? [];
+    const message = "Schema validation failed";
+    throw new SchemaValidationError(message, errors);
+  }
+  return data;
+};
+var isRequiredError = (error) => {
+  return error.keyword === "required";
+};
+var validateAllowingMissingRequired = (ajv, schema, data, isFinalAttempt = true) => {
+  const validate = ajv.compile(schema);
+  const valid = validate(data);
+  if (valid) {
+    return { valid: true, data };
+  }
+  const errors = validate.errors ?? [];
+  const nonRequiredErrors = errors.filter((error) => !isRequiredError(error));
+  if (nonRequiredErrors.length === 0) {
+    if (isFinalAttempt) {
+      return { valid: true, data };
+    }
+    return { valid: false, errors };
+  }
+  return { valid: false, errors: nonRequiredErrors };
+};
+
+// src/parsers/runner.ts
+import os from "os";
+import path from "path";
+import { rm, writeFile, readFile } from "fs/promises";
+import { exec } from "child_process";
+import { promisify } from "util";
+var execAsync = promisify(exec);
+var parseCommandOutput = (stdout) => {
+  let parsed;
+  try {
+    parsed = JSON.parse(stdout);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw new Error(`Parser command produced invalid JSON: ${message}
+Output: ${stdout.slice(0, 200)}`);
+  }
+  const serialized = validateSerializedArtifacts(parsed);
+  return hydrateSerializedArtifacts(serialized);
+};
+var spawnAndCapture = async (command, stdinBuffer) => {
+  if (!command.trim()) {
+    throw new Error(`Empty command: ${command}`);
+  }
+  try {
+    const options = stdinBuffer ? { input: stdinBuffer.toString(), maxBuffer: 50 * 1024 * 1024 } : { maxBuffer: 50 * 1024 * 1024 };
+    const { stdout } = await execAsync(command, options);
+    return stdout;
+  } catch (error) {
+    if (error instanceof Error && "stderr" in error) {
+      const stderr = error.stderr;
+      throw new Error(
+        `Parser command failed: ${command}
+Stderr: ${stderr?.slice(0, 500) ?? ""}`
+      );
+    }
+    throw error;
+  }
+};
+var runNpmParser = async (pkg, input, mimeType) => {
+  const mod = await import(pkg);
+  const hasParseFile = typeof mod.parseFile === "function";
+  const hasParseStream = typeof mod.parseStream === "function";
+  if (!hasParseFile && !hasParseStream) {
+    throw new Error(
+      `npm parser package "${pkg}" exports neither parseFile nor parseStream`
+    );
+  }
+  if (input.kind === "file") {
+    if (hasParseFile) {
+      return mod.parseFile(input.path, mimeType);
+    }
+    const { createReadStream } = await import("fs");
+    const { Readable } = await import("stream");
+    const nodeStream = createReadStream(input.path);
+    const stream = Readable.toWeb(nodeStream);
+    return mod.parseStream(stream, mimeType);
+  }
+  if (hasParseStream) {
+    const stream = new ReadableStream({
+      start(controller) {
+        controller.enqueue(input.buffer);
+        controller.close();
+      }
+    });
+    return mod.parseStream(stream, mimeType);
+  }
+  const tmpFile = path.join(os.tmpdir(), `struktur-parse-${crypto.randomUUID()}`);
+  try {
+    await writeFile(tmpFile, input.buffer);
+    return await mod.parseFile(tmpFile, mimeType);
+  } finally {
+    await rm(tmpFile, { force: true });
+  }
+};
+var runCommandFileParser = async (command, input) => {
+  let filePath;
+  let tempFile = null;
+  if (input.kind === "file") {
+    filePath = input.path;
+  } else {
+    tempFile = path.join(os.tmpdir(), `struktur-parse-${crypto.randomUUID()}`);
+    await writeFile(tempFile, input.buffer);
+    filePath = tempFile;
+  }
+  try {
+    const interpolated = command.replace(/FILE_PATH/g, filePath);
+    const stdout = await spawnAndCapture(interpolated);
+    return parseCommandOutput(stdout);
+  } finally {
+    if (tempFile) {
+      await rm(tempFile, { force: true });
+    }
+  }
+};
+var runCommandStdinParser = async (command, input) => {
+  let buffer;
+  if (input.kind === "file") {
+    buffer = await readFile(input.path);
+  } else {
+    buffer = input.buffer;
+  }
+  const stdout = await spawnAndCapture(command, buffer);
+  return parseCommandOutput(stdout);
+};
+var runParser = async (def, input, mimeType) => {
+  switch (def.type) {
+    case "npm":
+      return runNpmParser(def.package, input, mimeType);
+    case "command-file":
+      return runCommandFileParser(def.command, input);
+    case "command-stdin":
+      return runCommandStdinParser(def.command, input);
+    case "inline": {
+      let buffer;
+      if (input.kind === "file") {
+        buffer = await readFile(input.path);
+      } else {
+        buffer = input.buffer;
+      }
+      return [await def.handler(buffer)];
+    }
+    default: {
+      const _exhaustive = def;
+      throw new Error(`Unknown parser type: ${_exhaustive.type}`);
+    }
+  }
+};
+
+// src/artifacts/input.ts
+import { readFile as readFile2 } from "fs/promises";
+
+// src/parsers/mime.ts
+import path2 from "path";
+var MAGIC_BYTES = [
+  // PDF: %PDF
+  { mimeType: "application/pdf", bytes: [37, 80, 68, 70] },
+  // PNG: 89 50 4E 47
+  { mimeType: "image/png", bytes: [137, 80, 78, 71] },
+  // JPEG: FF D8 FF
+  { mimeType: "image/jpeg", bytes: [255, 216, 255] },
+  // GIF: GIF8
+  { mimeType: "image/gif", bytes: [71, 73, 70, 56] },
+  // ZIP / Office Open XML (DOCX/XLSX/PPTX all start with PK\x03\x04)
+  {
+    mimeType: "application/zip",
+    bytes: [80, 75, 3, 4]
+  }
+];
+var isWebP = (header) => {
+  if (header.length < 12) return false;
+  const riff = header[0] === 82 && header[1] === 73 && header[2] === 70 && header[3] === 70;
+  const webp = header[8] === 87 && header[9] === 69 && header[10] === 66 && header[11] === 80;
+  return riff && webp;
+};
+var matchesMagicBytes = (header, bytes, offset = 0) => {
+  if (header.length < offset + bytes.length) return false;
+  return bytes.every((b, i) => header[offset + i] === b);
+};
+var detectFromMagicBytes = (header) => {
+  if (isWebP(header)) return "image/webp";
+  for (const { mimeType, bytes, offset } of MAGIC_BYTES) {
+    if (matchesMagicBytes(header, bytes, offset ?? 0)) {
+      return mimeType;
+    }
+  }
+  return null;
+};
+var EXTENSION_MIME_MAP = {
+  ".txt": "text/plain",
+  ".md": "text/markdown",
+  ".markdown": "text/markdown",
+  ".html": "text/html",
+  ".htm": "text/html",
+  ".json": "application/json",
+  ".pdf": "application/pdf",
+  ".png": "image/png",
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".gif": "image/gif",
+  ".webp": "image/webp",
+  ".csv": "text/csv",
+  ".xml": "application/xml",
+  ".yaml": "application/yaml",
+  ".yml": "application/yaml",
+  ".docx": "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+  ".xlsx": "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+  ".pptx": "application/vnd.openxmlformats-officedocument.presentationml.presentation",
+  ".mp4": "video/mp4",
+  ".mp3": "audio/mpeg",
+  ".wav": "audio/wav",
+  ".ogg": "audio/ogg",
+  ".svg": "image/svg+xml",
+  ".ts": "text/plain",
+  ".tsx": "text/plain",
+  ".js": "text/javascript",
+  ".jsx": "text/javascript",
+  ".css": "text/css",
+  ".toml": "application/toml"
+};
+async function detectMimeType(options) {
+  const { buffer, filePath, mimeOverride, npmParsers } = options;
+  if (mimeOverride) {
+    return mimeOverride;
+  }
+  if (buffer && buffer.length > 0) {
+    const header = buffer.subarray(0, 512);
+    const magicMime = detectFromMagicBytes(header);
+    if (magicMime) {
+      return magicMime;
+    }
+    if (npmParsers && npmParsers.length > 0) {
+      for (const entry of npmParsers) {
+        try {
+          const mod = await import(entry.def.package);
+          if (typeof mod.detectFileType === "function" && mod.detectFileType(header)) {
+            return entry.mimeType;
+          }
+        } catch {
+        }
+      }
+    }
+  }
+  if (filePath) {
+    const ext = path2.extname(filePath).toLowerCase();
+    if (ext && ext in EXTENSION_MIME_MAP) {
+      return EXTENSION_MIME_MAP[ext] ?? null;
+    }
+  }
+  return null;
+}
+
+// src/artifacts/input.ts
+var serializedArtifactImageSchema = {
+  type: "object",
+  required: ["type"],
+  properties: {
+    type: { const: "image" },
+    url: { type: "string", minLength: 1 },
+    base64: { type: "string", minLength: 1 },
+    text: { type: "string" },
+    x: { type: "number" },
+    y: { type: "number" },
+    width: { type: "number" },
+    height: { type: "number" },
+    imageType: { enum: ["embedded", "screenshot"] }
+  },
+  additionalProperties: false,
+  anyOf: [{ required: ["url"] }, { required: ["base64"] }]
+};
+var serializedArtifactContentSchema = {
+  type: "object",
+  properties: {
+    page: { type: "number" },
+    text: { type: "string" },
+    media: { type: "array", items: serializedArtifactImageSchema }
+  },
+  additionalProperties: false,
+  anyOf: [{ required: ["text"] }, { required: ["media"] }]
+};
+var serializedArtifactSchema = {
+  type: "object",
+  required: ["id", "type", "contents"],
+  properties: {
+    id: { type: "string", minLength: 1 },
+    type: { enum: ["text", "image", "pdf", "file"] },
+    contents: { type: "array", items: serializedArtifactContentSchema },
+    metadata: { type: "object", additionalProperties: true },
+    tokens: { type: "number" }
+  },
+  additionalProperties: false
+};
+var serializedArtifactsSchema = {
+  anyOf: [
+    serializedArtifactSchema,
+    { type: "array", items: serializedArtifactSchema }
+  ]
+};
+var inputParsers = [];
+var registerArtifactInputParser = (parser) => {
+  inputParsers.push(parser);
+};
+var clearArtifactInputParsers = () => {
+  inputParsers.length = 0;
+};
+var validateSerializedArtifacts = (data) => {
+  const ajv = createAjv();
+  const parsed = validateOrThrow(
+    ajv,
+    serializedArtifactsSchema,
+    data
+  );
+  return Array.isArray(parsed) ? parsed : [parsed];
+};
+var hydrateSerializedArtifacts = (items) => {
+  return items.map((item) => ({
+    ...item,
+    raw: async () => Buffer.from(JSON.stringify(item.contents ?? []))
+  }));
+};
+var parseSerializedArtifacts = (text) => {
+  const parsed = JSON.parse(text);
+  return validateSerializedArtifacts(parsed);
+};
+var splitTextIntoContents = (text) => {
+  const blocks = text.split(/\n\s*\n/g).map((block) => block.trim()).filter((block) => block.length > 0);
+  if (blocks.length === 0) {
+    return [{ text }];
+  }
+  return blocks.map((block) => ({ text: block }));
+};
+var bufferToTextArtifact2 = (buffer, id) => {
+  const text = buffer.toString();
+  return {
+    id: id ?? `artifact-${crypto.randomUUID()}`,
+    type: "text",
+    raw: async () => buffer,
+    contents: splitTextIntoContents(text)
+  };
+};
+var bufferToImageArtifact2 = (buffer, id) => {
+  return {
+    id: id ?? `artifact-${crypto.randomUUID()}`,
+    type: "image",
+    raw: async () => buffer,
+    contents: [
+      {
+        media: [{ type: "image", contents: buffer }]
+      }
+    ]
+  };
+};
+var parseBufferInput = async (buffer, mimeType, id, providers, parsers, includeImages, screenshots, screenshotScale, screenshotWidth) => {
+  if (parsers) {
+    const parserDef = parsers[mimeType];
+    if (parserDef) {
+      return runParser(parserDef, { kind: "buffer", buffer }, mimeType);
+    }
+  }
+  const registry = providers ?? defaultArtifactProviders;
+  const provider = registry[mimeType];
+  if (provider) {
+    return [await provider(buffer)];
+  }
+  if (mimeType === "application/json") {
+    try {
+      const parsed = JSON.parse(buffer.toString());
+      const serialized = validateSerializedArtifacts(parsed);
+      return hydrateSerializedArtifacts(serialized);
+    } catch {
+      throw new Error(
+        "Input is JSON but not in SerializedArtifact format. To parse arbitrary JSON files, configure a parser: struktur config parsers add --mime application/json ..."
+      );
+    }
+  }
+  if (mimeType === "application/pdf") {
+    const { parsePdf: parsePdf2 } = await Promise.resolve().then(() => (init_pdf(), pdf_exports));
+    const pdfOptions = {
+      includeImages,
+      screenshots,
+      screenshotScale,
+      screenshotWidth
+    };
+    return [await parsePdf2(buffer, pdfOptions)];
+  }
+  if (mimeType.startsWith("text/")) {
+    return [bufferToTextArtifact2(buffer, id)];
+  }
+  if (mimeType.startsWith("image/")) {
+    return [bufferToImageArtifact2(buffer, id)];
+  }
+  throw new Error(`Unsupported MIME type: ${mimeType}`);
+};
+var artifactJsonParser = {
+  name: "artifact-json",
+  canParse: (input) => input.kind === "artifact-json",
+  parse: async (input) => {
+    if (input.kind !== "artifact-json") {
+      return [];
+    }
+    const serialized = validateSerializedArtifacts(input.data);
+    return hydrateSerializedArtifacts(serialized);
+  }
+};
+var textParser = {
+  name: "text",
+  canParse: (input) => input.kind === "text",
+  parse: async (input) => {
+    if (input.kind !== "text") {
+      return [];
+    }
+    const buffer = Buffer.from(input.text);
+    return [bufferToTextArtifact2(buffer, input.id)];
+  }
+};
+var fileParser = {
+  name: "file",
+  canParse: (input) => input.kind === "file",
+  parse: async (input, options) => {
+    if (input.kind !== "file") {
+      return [];
+    }
+    const mimeType = input.mimeType ?? await detectMimeType({ filePath: input.path }) ?? "application/octet-stream";
+    if (mimeType === "application/json") {
+      const text = await readFile2(input.path, "utf-8");
+      try {
+        const parsed = JSON.parse(text);
+        const serialized = validateSerializedArtifacts(parsed);
+        return hydrateSerializedArtifacts(serialized);
+      } catch {
+        if (options?.parsers) {
+          const parserDef = options.parsers[mimeType];
+          if (parserDef) {
+            return runParser(parserDef, { kind: "file", path: input.path }, mimeType);
+          }
+        }
+        throw new Error(
+          `File "${input.path}" is JSON but not in SerializedArtifact format. To parse arbitrary JSON files, configure a parser: struktur config parsers add --mime application/json ...`
+        );
+      }
+    }
+    const buffer = await readFile2(input.path);
+    return parseBufferInput(
+      buffer,
+      mimeType,
+      input.id,
+      options?.providers,
+      options?.parsers,
+      options?.includeImages,
+      options?.screenshots,
+      options?.screenshotScale,
+      options?.screenshotWidth
+    );
+  }
+};
+var bufferParser = {
+  name: "buffer",
+  canParse: (input) => input.kind === "buffer",
+  parse: async (input, options) => {
+    if (input.kind !== "buffer") {
+      return [];
+    }
+    return parseBufferInput(
+      input.buffer,
+      input.mimeType,
+      input.id,
+      options?.providers,
+      options?.parsers,
+      options?.includeImages,
+      options?.screenshots,
+      options?.screenshotScale,
+      options?.screenshotWidth
+    );
+  }
+};
+var parse = async (input, options) => {
+  const parsers = options?.parsers ?? [
+    ...inputParsers,
+    artifactJsonParser,
+    textParser,
+    fileParser,
+    bufferParser
+  ];
+  const parser = parsers.find((candidate) => candidate.canParse(input));
+  if (!parser) {
+    throw new Error(`No artifact input parser available for ${input.kind}`);
+  }
+  return parser.parse(input, {
+    providers: options?.providers,
+    parsers: options?.parserConfig,
+    includeImages: options?.includeImages,
+    screenshots: options?.screenshots,
+    screenshotScale: options?.screenshotScale,
+    screenshotWidth: options?.screenshotWidth
+  });
+};
+
+// src/prompts/formatArtifacts.ts
+var imageRefFor = (artifactId, index, image) => {
+  if (image.url) {
+    return image.url;
+  }
+  const extension = image.base64 ? "png" : "bin";
+  return `artifact:${artifactId}/images/image${index + 1}.${extension}`;
+};
+var escapeXml = (value) => {
+  return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/\"/g, "&quot;").replace(/'/g, "&apos;");
+};
+var formatArtifactsXml = (artifacts) => {
+  const parts = [];
+  for (const artifact of artifacts) {
+    parts.push(`<artifact id="${escapeXml(artifact.id)}" type="${artifact.type}">`);
+    for (const content of artifact.contents) {
+      if (content.text) {
+        const pageAttr = content.page !== void 0 ? ` page="${content.page}"` : "";
+        parts.push(`  <text${pageAttr}>${escapeXml(content.text)}</text>`);
+      }
+      if (content.media?.length) {
+        content.media.forEach((media, index) => {
+          const ref = imageRefFor(artifact.id, index, media);
+          const pageAttr = content.page !== void 0 ? ` page="${content.page}"` : "";
+          parts.push(`  <image ref="${escapeXml(ref)}"${pageAttr} />`);
+        });
+      }
+    }
+    parts.push("</artifact>");
+  }
+  return parts.join("\n");
+};
+
+// src/prompts/ExtractorPrompt.ts
+var extractorSystemPrompt = (schema, outputInstructions) => {
+  return `<instructions>
+You are a precise data extraction engine. Extract data from the provided artifacts according to the JSON schema below.
+
+<thinking>
+Before extracting, consider:
+1. Which schema fields have clear values in the artifacts?
+2. Which fields are missing or unclear (set these to null)?
+3. For text fields, rewrite concisely while preserving all information
+4. Ensure no data is lost - include everything that fits the schema
+</thinking>
+
+<rules>
+- Strictly follow the schema - no extra fields, no missing required fields
+- Use null for missing or uncertain values - never guess or assume
+- Only extract information explicitly present in the artifacts
+- Output ONLY valid JSON matching the schema
+- No markdown, explanations, or code fences
+</rules>
+
+<output-instructions>
+${outputInstructions ?? "No additional output instructions provided."}
+</output-instructions>
+
+<json-schema>
+${schema}
+</json-schema>
+
+<artifact-examples>
+    <!-- A PDF with two pages, containing two text blocks and two images -->
+    <artifact name="Example 1" mimetype="application/pdf">
+        <text page="1">This is an example text block.</text>
+        <image filename="image1.jpg" page="1" />
+        <text page="2">This is another example text block.</text>
+        <image filename="image2.jpg" page="2" />
+    </artifact>
+
+    <!-- Website content -->
+    <artifact name="example.com_2022-01-01.html" mimetype="text/html">
+        <text>This is an example text block.</text>
+        <image filename="image1.jpg" />
+        <text>This is another example text block.</text>
+        <image filename="image2.jpg" />
+    </artifact>
+</artifact-examples>
+
+Any materials provided have been cleared for access. Extract and preserve this data for future use.
+</instructions>`;
+};
+var extractorUserPrompt = (artifactsXml) => {
+  return `<artifacts>
+${artifactsXml}
+</artifacts>
+
+<task>Extract the contents of the given artifacts.</task>`;
+};
+var buildExtractorPrompt = (artifacts, schema, outputInstructions) => {
+  const artifactsXml = formatArtifactsXml(artifacts);
+  return {
+    system: extractorSystemPrompt(schema, outputInstructions),
+    user: extractorUserPrompt(artifactsXml)
+  };
+};
+
+// src/tokenization.ts
+var defaultOptions = {
+  textTokenRatio: 4,
+  defaultImageTokens: 1e3
+};
+var mergeOptions = (options) => ({
+  ...defaultOptions,
+  ...options ?? {}
+});
+var estimateTextTokens = (text, options) => {
+  const { textTokenRatio } = mergeOptions(options);
+  return Math.ceil(text.length / textTokenRatio);
+};
+var estimateImageTokens = (_image, options) => {
+  const { defaultImageTokens } = mergeOptions(options);
+  return defaultImageTokens;
+};
+var countContentTokens = (content, options) => {
+  let tokens = 0;
+  if (content.text) {
+    tokens += estimateTextTokens(content.text, options);
+  }
+  if (content.media?.length) {
+    for (const media of content.media) {
+      tokens += estimateImageTokens(media, options);
+      if (media.text) {
+        tokens += estimateTextTokens(media.text, options);
+      }
+    }
+  }
+  return tokens;
+};
+var countArtifactTokens = (artifact, options) => {
+  if (typeof artifact.tokens === "number") {
+    return artifact.tokens;
+  }
+  return artifact.contents.reduce(
+    (total, content) => total + countContentTokens(content, options),
+    0
+  );
+};
+var countArtifactImages = (artifact) => {
+  return artifact.contents.reduce((count, content) => {
+    return count + (content.media?.length ?? 0);
+  }, 0);
+};
+
+// src/chunking/ArtifactSplitter.ts
+var splitTextIntoChunks = (content, maxTokens, options, debug, artifactId) => {
+  if (!content.text) {
+    return [content];
+  }
+  const totalTokens = estimateTextTokens(content.text, options);
+  if (totalTokens <= maxTokens) {
+    return [content];
+  }
+  const ratio = options?.textTokenRatio ?? 4;
+  const chunkSize = Math.max(1, maxTokens * ratio);
+  const chunks = [];
+  if (debug && artifactId) {
+    debug.chunkingSplit({
+      artifactId,
+      originalContentCount: 1,
+      splitContentCount: Math.ceil(content.text.length / chunkSize),
+      splitReason: "text_too_long",
+      originalTokens: totalTokens,
+      chunkSize
+    });
+  }
+  for (let offset = 0; offset < content.text.length; offset += chunkSize) {
+    const text = content.text.slice(offset, offset + chunkSize);
+    chunks.push({
+      page: content.page,
+      text,
+      media: offset === 0 ? content.media : void 0
+    });
+  }
+  return chunks;
+};
+var splitArtifact = (artifact, options) => {
+  const { maxTokens, maxImages, debug } = options;
+  const splitContents = [];
+  const totalTokens = countArtifactTokens(artifact, options);
+  debug?.chunkingStart({
+    artifactId: artifact.id,
+    totalTokens,
+    maxTokens,
+    maxImages
+  });
+  for (const content of artifact.contents) {
+    splitContents.push(...splitTextIntoChunks(content, maxTokens, options, debug, artifact.id));
+  }
+  const chunks = [];
+  let currentContents = [];
+  let currentTokens = 0;
+  let currentImages = 0;
+  for (const content of splitContents) {
+    const contentTokens = countContentTokens(content, options);
+    const contentImages = content.media?.length ?? 0;
+    const exceedsTokens = currentContents.length > 0 && currentTokens + contentTokens > maxTokens;
+    const exceedsImages = maxImages !== void 0 && currentContents.length > 0 && currentImages + contentImages > maxImages;
+    if (exceedsTokens || exceedsImages) {
+      if (debug) {
+        debug.chunkingSplit({
+          artifactId: artifact.id,
+          originalContentCount: splitContents.length,
+          splitContentCount: chunks.length + 1,
+          splitReason: exceedsTokens ? "content_limit" : "content_limit",
+          originalTokens: totalTokens,
+          chunkSize: maxTokens
+        });
+      }
+      chunks.push({
+        ...artifact,
+        id: `${artifact.id}:part:${chunks.length + 1}`,
+        contents: currentContents,
+        tokens: currentTokens
+      });
+      currentContents = [];
+      currentTokens = 0;
+      currentImages = 0;
+    }
+    currentContents.push(content);
+    currentTokens += contentTokens;
+    currentImages += contentImages;
+  }
+  if (currentContents.length > 0) {
+    chunks.push({
+      ...artifact,
+      id: `${artifact.id}:part:${chunks.length + 1}`,
+      contents: currentContents,
+      tokens: currentTokens
+    });
+  }
+  if (chunks.length === 0) {
+    chunks.push({
+      ...artifact,
+      id: `${artifact.id}:part:1`,
+      tokens: countArtifactTokens(artifact, options)
+    });
+  }
+  debug?.chunkingResult({
+    artifactId: artifact.id,
+    chunksCreated: chunks.length,
+    chunkSizes: chunks.map((c) => c.tokens ?? 0)
+  });
+  return chunks;
+};
+
+// src/chunking/ArtifactBatcher.ts
+var batchArtifacts = (artifacts, options) => {
+  const debug = options.debug;
+  const maxTokens = options.modelMaxTokens ? Math.min(options.maxTokens, options.modelMaxTokens) : options.maxTokens;
+  debug?.batchingStart({
+    totalArtifacts: artifacts.length,
+    maxTokens: options.maxTokens,
+    maxImages: options.maxImages,
+    modelMaxTokens: options.modelMaxTokens,
+    effectiveMaxTokens: maxTokens
+  });
+  const batches = [];
+  let currentBatch = [];
+  let currentTokens = 0;
+  let currentImages = 0;
+  for (const artifact of artifacts) {
+    const splitOptions = {
+      maxTokens,
+      debug
+    };
+    if (options.maxImages !== void 0) splitOptions.maxImages = options.maxImages;
+    if (options.textTokenRatio !== void 0) splitOptions.textTokenRatio = options.textTokenRatio;
+    if (options.defaultImageTokens !== void 0) splitOptions.defaultImageTokens = options.defaultImageTokens;
+    const splits = splitArtifact(artifact, splitOptions);
+    for (const split of splits) {
+      const splitTokens = countArtifactTokens(split, options);
+      const splitImages = countArtifactImages(split);
+      const exceedsTokens = currentBatch.length > 0 && currentTokens + splitTokens > maxTokens;
+      const exceedsImages = options.maxImages !== void 0 && currentBatch.length > 0 && currentImages + splitImages > options.maxImages;
+      if (exceedsTokens || exceedsImages) {
+        debug?.batchCreated({
+          batchIndex: batches.length,
+          artifactCount: currentBatch.length,
+          totalTokens: currentTokens,
+          totalImages: currentImages,
+          artifactIds: currentBatch.map((a) => a.id)
+        });
+        batches.push(currentBatch);
+        currentBatch = [];
+        currentTokens = 0;
+        currentImages = 0;
+      }
+      currentBatch.push(split);
+      currentTokens += splitTokens;
+      currentImages += splitImages;
+    }
+  }
+  if (currentBatch.length > 0) {
+    debug?.batchCreated({
+      batchIndex: batches.length,
+      artifactCount: currentBatch.length,
+      totalTokens: currentTokens,
+      totalImages: currentImages,
+      artifactIds: currentBatch.map((a) => a.id)
+    });
+    batches.push(currentBatch);
+  }
+  debug?.batchingComplete({
+    totalBatches: batches.length,
+    batches: batches.map((batch, index) => ({
+      index,
+      artifactCount: batch.length,
+      tokens: batch.reduce((sum, a) => sum + (a.tokens ?? 0), 0),
+      images: batch.reduce(
+        (sum, a) => sum + a.contents.reduce((c, content) => c + (content.media?.length ?? 0), 0),
+        0
+      )
+    }))
+  });
+  return batches;
+};
+
+// src/llm/message.ts
+var collectImages = (artifacts) => {
+  const parts = [];
+  for (const artifact of artifacts) {
+    for (const content of artifact.contents) {
+      if (!content.media?.length) {
+        continue;
+      }
+      for (const media of content.media) {
+        if (media.contents) {
+          parts.push({ type: "image", image: media.contents });
+        } else if (media.base64) {
+          parts.push({ type: "image", image: media.base64 });
+        } else if (media.url) {
+          parts.push({ type: "image", image: media.url });
+        }
+      }
+    }
+  }
+  return parts;
+};
+var buildUserContent = (text, artifacts) => {
+  const images = collectImages(artifacts);
+  if (images.length === 0) {
+    return text;
+  }
+  return [{ type: "text", text }, ...images];
+};
+
+// src/llm/LLMClient.ts
+import { generateText, Output, jsonSchema } from "ai";
+var isZodSchema = (schema) => {
+  return typeof schema === "object" && schema !== null && "safeParse" in schema && typeof schema.safeParse === "function";
+};
+var generateStructured = async (request) => {
+  const { telemetry, parentSpan } = request;
+  const llmSpan = telemetry?.startSpan({
+    name: "llm.generateStructured",
+    kind: "LLM",
+    parentSpan,
+    attributes: {
+      "llm.schema_name": request.schemaName ?? "extract",
+      "llm.strict": request.strict ?? false
+    }
+  });
+  const startTime = Date.now();
+  const schema = isZodSchema(request.schema) ? request.schema : jsonSchema(request.schema);
+  const preferredProvider = request.model?.__openrouter_provider;
+  if (preferredProvider && process.env.DEBUG) {
+    console.error(
+      `[DEBUG] Routing to OpenRouter provider: ${preferredProvider}`
+    );
+  }
+  const providerOptions = preferredProvider ? {
+    openrouter: {
+      provider: {
+        order: [preferredProvider]
+      }
+    }
+  } : void 0;
+  let result;
+  try {
+    result = await generateText({
+      model: request.model,
+      output: Output.object({
+        schema,
+        name: request.schemaName ?? "extract",
+        description: request.schemaDescription
+      }),
+      providerOptions: {
+        openai: {
+          strictJsonSchema: request.strict ?? false
+        }
+      },
+      system: request.system,
+      messages: request.messages ?? [
+        { role: "user", content: request.user }
+      ],
+      ...providerOptions ? { providerOptions } : {}
+    });
+  } catch (error) {
+    const modelId = typeof request.model === "object" && request.model !== null ? request.model.modelId ?? JSON.stringify(request.model) : String(request.model);
+    if (error && typeof error === "object" && "responseBody" in error && "statusCode" in error) {
+      const apiError = error;
+      const responseBody = apiError.responseBody;
+      const errorData = apiError.data;
+      if (typeof responseBody === "string" && responseBody.includes("No endpoints found that support image input")) {
+        throw new Error(
+          `Model "${modelId}" does not support image input. Please use a model that supports images (e.g., gpt-4o, claude-3-5-sonnet, gemini-1.5-pro) or remove the --images and --screenshots flags.`
+        );
+      }
+      if (errorData?.code === 500 || errorData?.message?.includes("Internal Server Error")) {
+        throw new Error(
+          `Provider error for model "${modelId}": Internal server error. The model or provider may be experiencing issues. Please try again or use a different model.`
+        );
+      }
+      if (apiError.statusCode === 401 || errorData?.code === 401) {
+        throw new Error(
+          `Authentication failed for model "${modelId}". Please check your API key is valid and has the necessary permissions.`
+        );
+      }
+      if (apiError.statusCode === 403 || errorData?.code === 403) {
+        throw new Error(
+          `Access denied for model "${modelId}". Your API key may not have access to this model. Please check your subscription or try a different model.`
+        );
+      }
+      if (apiError.statusCode === 429 || errorData?.code === 429) {
+        throw new Error(
+          `Rate limit exceeded for model "${modelId}". Please wait a moment and try again, or use a different model.`
+        );
+      }
+      if (apiError.statusCode === 404 || errorData?.code === 404) {
+        const errorMsg = errorData?.message || "Model not found";
+        throw new Error(
+          `Model "${modelId}" not found or unavailable. ${errorMsg} Please check the model name or try a different model.`
+        );
+      }
+      if (errorData?.message) {
+        throw new Error(
+          `Provider error for model "${modelId}": ${errorData.message}`
+        );
+      }
+    }
+    if (llmSpan && telemetry) {
+      const latencyMs = Date.now() - startTime;
+      telemetry.recordEvent(llmSpan, {
+        type: "llm_call",
+        model: modelId,
+        provider: "unknown",
+        // Will be determined by the model
+        input: {
+          messages: request.messages ?? [{ role: "user", content: typeof request.user === "string" ? request.user : "" }],
+          temperature: void 0,
+          maxTokens: void 0,
+          schema: request.schema
+        },
+        error: error instanceof Error ? error : new Error(String(error)),
+        latencyMs
+      });
+      telemetry.endSpan(llmSpan, {
+        status: "error",
+        error: error instanceof Error ? error : new Error(String(error)),
+        latencyMs
+      });
+    }
+    throw error;
+  }
+  const usageRaw = result.usage ?? {};
+  const inputTokens = "promptTokens" in usageRaw ? usageRaw.promptTokens : usageRaw.inputTokens ?? 0;
+  const outputTokens = "completionTokens" in usageRaw ? usageRaw.completionTokens : usageRaw.outputTokens ?? 0;
+  const totalTokens = "totalTokens" in usageRaw ? usageRaw.totalTokens : inputTokens + outputTokens;
+  const usage = {
+    inputTokens,
+    outputTokens,
+    totalTokens
+  };
+  if (llmSpan && telemetry) {
+    const latencyMs = Date.now() - startTime;
+    telemetry.recordEvent(llmSpan, {
+      type: "llm_call",
+      model: typeof request.model === "object" && request.model !== null ? request.model.modelId ?? "unknown" : String(request.model),
+      provider: preferredProvider ?? "unknown",
+      input: {
+        messages: request.messages ?? [{ role: "user", content: typeof request.user === "string" ? request.user : "" }],
+        temperature: void 0,
+        maxTokens: void 0,
+        schema: request.schema
+      },
+      output: {
+        content: JSON.stringify(result.output),
+        structured: true,
+        usage: {
+          input: inputTokens,
+          output: outputTokens,
+          total: totalTokens
+        }
+      },
+      latencyMs
+    });
+    telemetry.endSpan(llmSpan, {
+      status: "ok",
+      output: result.output,
+      latencyMs
+    });
+  }
+  return { data: result.output, usage };
+};
+
+// src/llm/RetryingRunner.ts
+var runWithRetries = async (options) => {
+  const { telemetry, parentSpan } = options;
+  const retrySpan = telemetry?.startSpan({
+    name: "struktur.validation_retry",
+    kind: "CHAIN",
+    parentSpan,
+    attributes: {
+      "retry.max_attempts": options.maxAttempts ?? 3,
+      "retry.schema_name": options.schemaName ?? "extract"
+    }
+  });
+  const ajv = createAjv();
+  const maxAttempts = options.maxAttempts ?? 3;
+  const messages = [{ role: "user", content: options.user }];
+  const debug = options.debug;
+  const callId = options.callId ?? `call_${Date.now()}_${Math.random().toString(36).slice(2, 11)}`;
+  let usage = { inputTokens: 0, outputTokens: 0, totalTokens: 0 };
+  let lastError;
+  const systemLength = options.system.length;
+  const userLength = typeof options.user === "string" ? options.user.length : JSON.stringify(options.user).length;
+  debug?.llmCallStart({
+    callId,
+    model: JSON.stringify(options.model),
+    schemaName: options.schemaName,
+    systemLength,
+    userLength,
+    artifactCount: Array.isArray(options.user) ? options.user.length : 0
+  });
+  debug?.promptSystem({ callId, system: options.system });
+  debug?.promptUser({ callId, user: options.user });
+  for (let attempt = 1; attempt <= maxAttempts; attempt += 1) {
+    const executor = options.execute ?? generateStructured;
+    const isFinalAttempt = attempt === maxAttempts;
+    const useStrictValidation = options.strict === true || isFinalAttempt;
+    debug?.validationStart({
+      callId,
+      attempt,
+      maxAttempts,
+      strict: useStrictValidation
+    });
+    const startTime = Date.now();
+    const result = await executor({
+      model: options.model,
+      schema: options.schema,
+      schemaName: options.schemaName,
+      system: options.system,
+      user: options.user,
+      messages,
+      strict: options.strict,
+      telemetry,
+      parentSpan: retrySpan
+    });
+    const durationMs = Date.now() - startTime;
+    usage = {
+      inputTokens: usage.inputTokens + result.usage.inputTokens,
+      outputTokens: usage.outputTokens + result.usage.outputTokens,
+      totalTokens: usage.totalTokens + result.usage.totalTokens
+    };
+    debug?.rawResponse({ callId, response: result.data });
+    try {
+      if (useStrictValidation) {
+        const validated = validateOrThrow(
+          ajv,
+          options.schema,
+          result.data
+        );
+        debug?.validationSuccess({ callId, attempt });
+        debug?.llmCallComplete({
+          callId,
+          success: true,
+          inputTokens: usage.inputTokens,
+          outputTokens: usage.outputTokens,
+          totalTokens: usage.totalTokens,
+          durationMs
+        });
+        if (retrySpan && telemetry) {
+          telemetry.recordEvent(retrySpan, {
+            type: "validation",
+            attempt,
+            maxAttempts,
+            schema: options.schema,
+            input: result.data,
+            success: true,
+            latencyMs: durationMs
+          });
+          telemetry.endSpan(retrySpan, {
+            status: "ok",
+            output: validated,
+            latencyMs: durationMs
+          });
+        }
+        return { data: validated, usage };
+      } else {
+        const validationResult = validateAllowingMissingRequired(
+          ajv,
+          options.schema,
+          result.data,
+          isFinalAttempt
+        );
+        if (validationResult.valid) {
+          debug?.validationSuccess({ callId, attempt });
+          debug?.llmCallComplete({
+            callId,
+            success: true,
+            inputTokens: usage.inputTokens,
+            outputTokens: usage.outputTokens,
+            totalTokens: usage.totalTokens,
+            durationMs
+          });
+          if (retrySpan && telemetry) {
+            telemetry.recordEvent(retrySpan, {
+              type: "validation",
+              attempt,
+              maxAttempts,
+              schema: options.schema,
+              input: result.data,
+              success: true,
+              latencyMs: durationMs
+            });
+            telemetry.endSpan(retrySpan, {
+              status: "ok",
+              output: validationResult.data,
+              latencyMs: durationMs
+            });
+          }
+          return { data: validationResult.data, usage };
+        }
+        throw new SchemaValidationError(
+          "Schema validation failed",
+          validationResult.errors
+        );
+      }
+    } catch (error) {
+      lastError = error;
+      if (error instanceof SchemaValidationError) {
+        debug?.validationFailed({
+          callId,
+          attempt,
+          errors: error.errors
+        });
+        if (retrySpan && telemetry) {
+          telemetry.recordEvent(retrySpan, {
+            type: "validation",
+            attempt,
+            maxAttempts,
+            schema: options.schema,
+            input: result.data,
+            success: false,
+            errors: error.errors,
+            latencyMs: durationMs
+          });
+        }
+        const nextAttempt = attempt + 1;
+        if (nextAttempt <= maxAttempts) {
+          await options.events?.onRetry?.({
+            attempt: nextAttempt,
+            maxAttempts,
+            reason: "schema_validation_failed"
+          });
+          debug?.retry({
+            callId,
+            attempt: nextAttempt,
+            maxAttempts,
+            reason: "schema_validation_failed"
+          });
+        }
+        const errorPayload = JSON.stringify(error.errors, null, 2);
+        const errorMessage = `<validation-errors>
+${errorPayload}
+</validation-errors>`;
+        messages.push({ role: "user", content: errorMessage });
+        await options.events?.onMessage?.({
+          role: "user",
+          content: errorMessage
+        });
+        continue;
+      }
+      debug?.llmCallComplete({
+        callId,
+        success: false,
+        inputTokens: usage.inputTokens,
+        outputTokens: usage.outputTokens,
+        totalTokens: usage.totalTokens,
+        durationMs,
+        error: error.message
+      });
+      if (retrySpan && telemetry) {
+        telemetry.endSpan(retrySpan, {
+          status: "error",
+          error,
+          latencyMs: durationMs
+        });
+      }
+      break;
+    }
+  }
+  throw lastError ?? new Error("Unknown extraction error");
+};
+
+// src/strategies/utils.ts
+var serializeSchema = (schema) => {
+  return JSON.stringify(schema);
+};
+var mergeUsage = (usages) => {
+  return usages.reduce(
+    (acc, usage) => ({
+      inputTokens: acc.inputTokens + usage.inputTokens,
+      outputTokens: acc.outputTokens + usage.outputTokens,
+      totalTokens: acc.totalTokens + usage.totalTokens
+    }),
+    { inputTokens: 0, outputTokens: 0, totalTokens: 0 }
+  );
+};
+var getBatches = (artifacts, options, debug, telemetry, parentSpan) => {
+  const chunkingSpan = telemetry?.startSpan({
+    name: "struktur.chunking",
+    kind: "RETRIEVER",
+    parentSpan,
+    attributes: {
+      "chunking.artifact_count": artifacts.length,
+      "chunking.max_tokens": options.maxTokens,
+      "chunking.max_images": options.maxImages
+    }
+  });
+  const batches = batchArtifacts(artifacts, { ...options, debug });
+  if (chunkingSpan && telemetry) {
+    batches.forEach((batch, index) => {
+      telemetry.recordEvent(chunkingSpan, {
+        type: "chunk",
+        chunkIndex: index,
+        totalChunks: batches.length,
+        tokens: batch.reduce((sum, a) => sum + (a.tokens || 0), 0),
+        images: batch.reduce((sum, a) => sum + (a.contents?.flatMap((c) => c.media || []).length || 0), 0)
+      });
+    });
+    telemetry.endSpan(chunkingSpan, {
+      status: "ok",
+      output: { batchCount: batches.length }
+    });
+  }
+  return batches;
+};
+var extractWithPrompt = async (options) => {
+  const userContent = buildUserContent(options.user, options.artifacts);
+  const result = await runWithRetries({
+    model: options.model,
+    schema: options.schema,
+    system: options.system,
+    user: userContent,
+    events: options.events,
+    execute: options.execute,
+    strict: options.strict,
+    debug: options.debug,
+    callId: options.callId,
+    telemetry: options.telemetry,
+    parentSpan: options.parentSpan
+  });
+  return result;
+};
+
+// src/strategies/SimpleStrategy.ts
+var SimpleStrategy = class {
+  name = "simple";
+  config;
+  constructor(config) {
+    this.config = config;
+  }
+  getEstimatedSteps() {
+    return 3;
+  }
+  async run(options) {
+    const debug = options.debug;
+    const telemetry = options.telemetry ?? void 0;
+    const strategySpan = telemetry?.startSpan({
+      name: "strategy.simple",
+      kind: "CHAIN",
+      attributes: {
+        "strategy.name": this.name,
+        "strategy.artifacts.count": options.artifacts.length
+      }
+    });
+    const schema = serializeSchema(options.schema);
+    const { system, user } = buildExtractorPrompt(
+      options.artifacts,
+      schema,
+      this.config.outputInstructions
+    );
+    await options.events?.onStep?.({
+      step: 1,
+      total: this.getEstimatedSteps(),
+      label: "extract"
+    });
+    debug?.step({
+      step: 1,
+      total: this.getEstimatedSteps(),
+      label: "extract",
+      strategy: this.name
+    });
+    const result = await extractWithPrompt({
+      model: this.config.model,
+      schema: options.schema,
+      system,
+      user,
+      artifacts: options.artifacts,
+      events: options.events,
+      execute: this.config.execute,
+      strict: options.strict ?? this.config.strict,
+      debug,
+      callId: "simple_extract",
+      telemetry,
+      parentSpan: strategySpan
+    });
+    debug?.step({
+      step: 2,
+      total: this.getEstimatedSteps(),
+      label: "complete",
+      strategy: this.name
+    });
+    telemetry?.endSpan(strategySpan, {
+      status: "ok",
+      output: result.data
+    });
+    return { data: result.data, usage: result.usage };
+  }
+};
+var simple = (config) => {
+  return new SimpleStrategy(config);
+};
+
+// src/prompts/ParallelMergerPrompt.ts
+var buildParallelMergerPrompt = (schema, dataList) => {
+  const jsonObjects = dataList.filter((item) => item !== null && item !== void 0).map((item) => JSON.stringify(item)).map((json) => `<json-object>${json}</json-object>`).join("\n");
+  const system = `You are a data merger. Combine multiple JSON objects into one object matching the provided schema.
+
+<thinking>
+Before merging, consider:
+1. Which input objects contain data for each schema field?
+2. How should conflicting values be resolved (prefer more complete/recent data)?
+3. Are there arrays that need to be concatenated vs deduplicated?
+4. Ensure NO information is lost from any input
+</thinking>
+
+<rules>
+- Produce a single JSON object following the schema exactly
+- Combine all information from input objects without losing data
+- Resolve conflicts intelligently (prefer richer/more specific data)
+- Output ONLY valid JSON - no markdown, no explanations
+</rules>`;
+  const user = `<json-schema>
+${schema}
+</json-schema>
+
+<json-objects>
+${jsonObjects}
+</json-objects>`;
+  return { system, user };
+};
+
+// src/strategies/concurrency.ts
+var runConcurrently = async (tasks, concurrency) => {
+  const results = [];
+  for (let i = 0; i < tasks.length; i += concurrency) {
+    const chunk = tasks.slice(i, i + concurrency).map((task) => task());
+    const chunkResults = await Promise.all(chunk);
+    results.push(...chunkResults);
+  }
+  return results;
+};
+
+// src/strategies/ParallelStrategy.ts
+var ParallelStrategy = class {
+  name = "parallel";
+  config;
+  constructor(config) {
+    this.config = config;
+  }
+  getEstimatedSteps(artifacts) {
+    const batches = getBatches(artifacts, {
+      maxTokens: this.config.chunkSize,
+      maxImages: this.config.maxImages
+    });
+    return batches.length + 3;
+  }
+  async run(options) {
+    const debug = options.debug;
+    const { telemetry } = options;
+    const strategySpan = telemetry?.startSpan({
+      name: "strategy.parallel",
+      kind: "CHAIN",
+      attributes: {
+        "strategy.name": this.name,
+        "strategy.artifacts.count": options.artifacts.length,
+        "strategy.chunk_size": this.config.chunkSize,
+        "strategy.concurrency": this.config.concurrency
+      }
+    });
+    const batches = getBatches(
+      options.artifacts,
+      {
+        maxTokens: this.config.chunkSize,
+        maxImages: this.config.maxImages
+      },
+      debug,
+      telemetry ?? void 0,
+      strategySpan
+    );
+    const schema = serializeSchema(options.schema);
+    const totalSteps = this.getEstimatedSteps(options.artifacts);
+    let step = 1;
+    await options.events?.onStep?.({
+      step,
+      total: totalSteps,
+      label: batches.length > 1 ? `batch 1/${batches.length}` : "extract"
+    });
+    debug?.step({
+      step,
+      total: totalSteps,
+      label: batches.length > 1 ? `batch 1/${batches.length}` : "extract",
+      strategy: this.name
+    });
+    const tasks = batches.map((batch, index) => async () => {
+      const prompt = buildExtractorPrompt(
+        batch,
+        schema,
+        this.config.outputInstructions
+      );
+      const result = await extractWithPrompt({
+        model: this.config.model,
+        schema: options.schema,
+        system: prompt.system,
+        user: prompt.user,
+        artifacts: batch,
+        events: options.events,
+        execute: this.config.execute,
+        strict: options.strict ?? this.config.strict,
+        debug,
+        callId: `parallel_batch_${index + 1}`,
+        telemetry: telemetry ?? void 0,
+        parentSpan: strategySpan
+      });
+      const completedIndex = index + 1;
+      if (completedIndex < batches.length) {
+        step += 1;
+        await options.events?.onStep?.({
+          step,
+          total: totalSteps,
+          label: `batch ${completedIndex + 1}/${batches.length}`
+        });
+        debug?.step({
+          step,
+          total: totalSteps,
+          label: `batch ${completedIndex + 1}/${batches.length}`,
+          strategy: this.name
+        });
+      }
+      return result;
+    });
+    const results = await runConcurrently(
+      tasks,
+      this.config.concurrency ?? batches.length
+    );
+    debug?.mergeStart({
+      mergeId: "parallel_merge",
+      inputCount: results.length,
+      strategy: this.name
+    });
+    const mergeSpan = telemetry?.startSpan({
+      name: "struktur.merge",
+      kind: "CHAIN",
+      parentSpan: strategySpan,
+      attributes: {
+        "merge.strategy": "parallel",
+        "merge.input_count": results.length
+      }
+    });
+    const mergePrompt = buildParallelMergerPrompt(
+      schema,
+      results.map((r) => r.data)
+    );
+    const merged = await extractWithPrompt({
+      model: this.config.mergeModel,
+      schema: options.schema,
+      system: mergePrompt.system,
+      user: mergePrompt.user,
+      artifacts: [],
+      events: options.events,
+      execute: this.config.execute,
+      strict: this.config.strict,
+      debug,
+      callId: "parallel_merge",
+      telemetry: telemetry ?? void 0,
+      parentSpan: mergeSpan
+    });
+    step += 1;
+    await options.events?.onStep?.({
+      step,
+      total: totalSteps,
+      label: "merge"
+    });
+    debug?.step({
+      step,
+      total: totalSteps,
+      label: "merge",
+      strategy: this.name
+    });
+    debug?.mergeComplete({ mergeId: "parallel_merge", success: true });
+    if (mergeSpan && telemetry) {
+      telemetry.recordEvent(mergeSpan, {
+        type: "merge",
+        strategy: "parallel",
+        inputCount: results.length,
+        outputCount: 1
+      });
+      telemetry.endSpan(mergeSpan, {
+        status: "ok",
+        output: merged.data
+      });
+    }
+    telemetry?.endSpan(strategySpan, {
+      status: "ok",
+      output: merged.data
+    });
+    return {
+      data: merged.data,
+      usage: mergeUsage([...results.map((r) => r.usage), merged.usage])
+    };
+  }
+};
+var parallel = (config) => {
+  return new ParallelStrategy(config);
+};
+
+// src/prompts/SequentialExtractorPrompt.ts
+var sequentialSystemPrompt = (schema, outputInstructions) => {
+  return `<instructions>
+You are a precise data extraction engine. Extract data from provided artifacts according to the JSON schema, enriching any previous data you receive.
+
+<thinking>
+Before extracting, consider:
+1. Review previous data - what needs to be preserved vs enriched?
+2. Which new fields have clear values in the artifacts?
+3. Which fields remain missing or unclear (keep null from previous or set to null)?
+4. Can new information improve the structure of existing data?
+5. Ensure NO information is lost from previous data
+</thinking>
+
+<rules>
+- Merge new artifacts into existing data - do not create fresh objects
+- Preserve ALL previous data - losing information breaks the processing chain
+- Use null for missing/uncertain values in new fields
+- Only extract information explicitly present in the artifacts
+- Output ONLY valid JSON matching the schema
+- No markdown, explanations, or code fences
+</rules>
+
+<image-handling>
+Some schema properties may reference artifact IDs (e.g., 'xxx_artifact_id' fields).
+When assigning images to properties:
+- Use format: artifact:ID/images/imageNUM.EXT (e.g., 'artifact:123456/images/image1.jpg')
+- Only reference images you can actually see in the provided documents/images
+- Image references are visible in artifact XML or written on images
+- NEVER make up artifact IDs or use normal URLs
+</image-handling>
+
+<output-instructions>
+${outputInstructions ?? "No additional output instructions provided."}
+</output-instructions>
+
+<json-schema>
+${schema}
+</json-schema>
+
+<how-to-output>
+Return the complete extracted data as valid JSON matching the schema.
+Include all information from previous data, enriched with the new artifacts.
+</how-to-output>
+</instructions>`;
+};
+var sequentialUserPrompt = (artifactsXml, previousData, outputInstructions) => {
+  return `${artifactsXml}
+
+<previous-data>
+${previousData}
+</previous-data>
+
+<task>
+    Extract the contents of the given artifacts and ADD/MERGE them into the previous data contained in the <previous-data> tag.
+    You MUST NOT lose any information from the previous data. All previous data must be included in your response.
+</task>
+
+<output-instructions>
+${outputInstructions ?? ""}
+</output-instructions>`;
+};
+var buildSequentialPrompt = (artifacts, schema, previousData, outputInstructions) => {
+  const artifactsXml = formatArtifactsXml(artifacts);
+  return {
+    system: sequentialSystemPrompt(schema, outputInstructions),
+    user: sequentialUserPrompt(artifactsXml, previousData, outputInstructions)
+  };
+};
+
+// src/strategies/SequentialStrategy.ts
+var SequentialStrategy = class {
+  name = "sequential";
+  config;
+  constructor(config) {
+    this.config = config;
+  }
+  getEstimatedSteps(artifacts) {
+    const batches = getBatches(artifacts, {
+      maxTokens: this.config.chunkSize,
+      maxImages: this.config.maxImages
+    });
+    return batches.length + 2;
+  }
+  async run(options) {
+    const debug = options.debug;
+    const { telemetry } = options;
+    const strategySpan = telemetry?.startSpan({
+      name: "strategy.sequential",
+      kind: "CHAIN",
+      attributes: {
+        "strategy.name": this.name,
+        "strategy.artifacts.count": options.artifacts.length,
+        "strategy.chunk_size": this.config.chunkSize
+      }
+    });
+    const batches = getBatches(
+      options.artifacts,
+      {
+        maxTokens: this.config.chunkSize,
+        maxImages: this.config.maxImages
+      },
+      debug,
+      telemetry ?? void 0,
+      strategySpan
+    );
+    const schema = serializeSchema(options.schema);
+    let currentData;
+    const usages = [];
+    const totalSteps = this.getEstimatedSteps(options.artifacts);
+    let step = 1;
+    await options.events?.onStep?.({
+      step,
+      total: totalSteps,
+      label: batches.length > 1 ? `batch 1/${batches.length}` : "extract"
+    });
+    debug?.step({
+      step,
+      total: totalSteps,
+      label: batches.length > 1 ? `batch 1/${batches.length}` : "extract",
+      strategy: this.name
+    });
+    for (const [index, batch] of batches.entries()) {
+      const previousData = currentData ? JSON.stringify(currentData) : "{}";
+      const prompt = buildSequentialPrompt(
+        batch,
+        schema,
+        previousData,
+        this.config.outputInstructions
+      );
+      const result = await extractWithPrompt({
+        model: this.config.model,
+        schema: options.schema,
+        system: prompt.system,
+        user: prompt.user,
+        artifacts: batch,
+        events: options.events,
+        execute: this.config.execute,
+        strict: options.strict ?? this.config.strict,
+        debug,
+        callId: `sequential_batch_${index + 1}`,
+        telemetry: telemetry ?? void 0,
+        parentSpan: strategySpan
+      });
+      currentData = result.data;
+      usages.push(result.usage);
+      step += 1;
+      if (index < batches.length - 1) {
+        await options.events?.onStep?.({
+          step,
+          total: totalSteps,
+          label: `batch ${index + 2}/${batches.length}`
+        });
+        debug?.step({
+          step,
+          total: totalSteps,
+          label: `batch ${index + 2}/${batches.length}`,
+          strategy: this.name
+        });
+      }
+    }
+    if (!currentData) {
+      throw new Error("No data extracted from sequential strategy");
+    }
+    telemetry?.endSpan(strategySpan, {
+      status: "ok",
+      output: currentData
+    });
+    return { data: currentData, usage: mergeUsage(usages) };
+  }
+};
+var sequential = (config) => {
+  return new SequentialStrategy(config);
+};
+
+// src/prompts/DeduplicationPrompt.ts
+var buildDeduplicationPrompt = (schema, data, exampleKeys = ["items.3", "items.5"]) => {
+  const system = `You are a deduplication engine. Identify duplicate entries in structured data.
+
+<thinking>
+Before deduplicating, consider:
+1. Which fields indicate uniqueness for each entity type?
+2. Are entries duplicates if they share key fields but differ in minor details?
+3. Which entry should be kept (prefer more complete data)?
+</thinking>
+
+<rules>
+- Identify entries that represent the same entity
+- Return paths to duplicates using dot notation (e.g., "items.3", "items.5")
+- Output ONLY JSON in format: { "keys": ["path1", "path2"] }
+- No markdown, no explanations
+</rules>`;
+  const user = `<json-schema>
+${schema}
+</json-schema>
+
+<json-data>
+${JSON.stringify(data)}
+</json-data>
+
+<task>Identify duplicate entries in the data and return their paths in the format: { "keys": ["path1", "path2"] }</task>
+
+<example>
+If items at indices 3 and 5 are duplicates, return: { "keys": ["items.3", "items.5"] }
+</example>`;
+  return { system, user };
+};
+
+// src/merge/SmartDataMerger.ts
+var isArraySchema = (schema) => {
+  if (schema.type === "array") {
+    return true;
+  }
+  return false;
+};
+var isObjectSchema = (schema) => {
+  return schema.type === "object" && typeof schema.properties === "object";
+};
+var SmartDataMerger = class {
+  schema;
+  constructor(schema) {
+    this.schema = schema;
+  }
+  merge(currentData, newData) {
+    const merged = { ...currentData };
+    const properties = this.schema.properties ?? {};
+    for (const [key, propSchema] of Object.entries(properties)) {
+      const currentValue = currentData[key];
+      const newValue = newData[key];
+      if (isArraySchema(propSchema)) {
+        merged[key] = [
+          ...Array.isArray(currentValue) ? currentValue : [],
+          ...Array.isArray(newValue) ? newValue : []
+        ];
+        continue;
+      }
+      if (isObjectSchema(propSchema)) {
+        merged[key] = {
+          ...typeof currentValue === "object" && currentValue ? currentValue : {},
+          ...typeof newValue === "object" && newValue ? newValue : {}
+        };
+        continue;
+      }
+      if (newValue !== void 0 && newValue !== null && newValue !== "") {
+        merged[key] = newValue;
+      } else if (currentValue !== void 0) {
+        merged[key] = currentValue;
+      }
+    }
+    return merged;
+  }
+};
+
+// src/merge/Deduplicator.ts
+var fnv1a32 = (str) => {
+  let hash = 2166136261;
+  for (let i = 0; i < str.length; i++) {
+    hash ^= str.charCodeAt(i);
+    hash = Math.imul(hash, 16777619);
+  }
+  return hash >>> 0;
+};
+var stableStringify = (value) => {
+  if (value === null || typeof value !== "object") {
+    return JSON.stringify(value);
+  }
+  if (Array.isArray(value)) {
+    return `[${value.map((item) => stableStringify(item)).join(",")}]`;
+  }
+  const entries = Object.entries(value).sort(([a], [b]) => a.localeCompare(b)).map(([key, val]) => `"${key}":${stableStringify(val)}`);
+  return `{${entries.join(",")}}`;
+};
+var findExactDuplicatesWithHashing = (items) => {
+  const seen = /* @__PURE__ */ new Map();
+  const duplicates = [];
+  items.forEach((item, index) => {
+    const hash = fnv1a32(stableStringify(item));
+    if (seen.has(hash)) {
+      duplicates.push(index);
+      return;
+    }
+    seen.set(hash, index);
+  });
+  return duplicates;
+};
+var deduplicateByIndices = (items, indices) => {
+  const remove = new Set(indices);
+  return items.filter((_, index) => !remove.has(index));
+};
+
+// src/strategies/ParallelAutoMergeStrategy.ts
+var dedupeSchema = {
+  type: "object",
+  properties: {
+    keys: { type: "array", items: { type: "string" } }
+  },
+  required: ["keys"],
+  additionalProperties: false
+};
+var dedupeArrays = (data) => {
+  const result = { ...data };
+  for (const [key, value] of Object.entries(result)) {
+    if (Array.isArray(value)) {
+      const duplicates = findExactDuplicatesWithHashing(value);
+      result[key] = deduplicateByIndices(value, duplicates);
+    }
+  }
+  return result;
+};
+var removeByPath = (data, path5) => {
+  const [root, indexStr] = path5.split(".");
+  const index = Number(indexStr);
+  if (!root || Number.isNaN(index)) {
+    return data;
+  }
+  const value = data[root];
+  if (!Array.isArray(value)) {
+    return data;
+  }
+  const next = [...value];
+  next.splice(index, 1);
+  return { ...data, [root]: next };
+};
+var ParallelAutoMergeStrategy = class {
+  name = "parallel-auto-merge";
+  config;
+  constructor(config) {
+    this.config = config;
+  }
+  getEstimatedSteps(artifacts) {
+    const batches = getBatches(artifacts, {
+      maxTokens: this.config.chunkSize,
+      maxImages: this.config.maxImages
+    });
+    return batches.length + 3;
+  }
+  async run(options) {
+    const debug = options.debug;
+    const { telemetry } = options;
+    const strategySpan = telemetry?.startSpan({
+      name: "strategy.parallel-auto-merge",
+      kind: "CHAIN",
+      attributes: {
+        "strategy.name": this.name,
+        "strategy.artifacts.count": options.artifacts.length,
+        "strategy.chunk_size": this.config.chunkSize,
+        "strategy.concurrency": this.config.concurrency
+      }
+    });
+    const batches = getBatches(
+      options.artifacts,
+      {
+        maxTokens: this.config.chunkSize,
+        maxImages: this.config.maxImages
+      },
+      debug,
+      telemetry ?? void 0,
+      strategySpan
+    );
+    const schema = serializeSchema(options.schema);
+    const totalSteps = this.getEstimatedSteps(options.artifacts);
+    let step = 1;
+    const tasks = batches.map((batch, index) => async () => {
+      const prompt = buildExtractorPrompt(
+        batch,
+        schema,
+        this.config.outputInstructions
+      );
+      const result = await extractWithPrompt({
+        model: this.config.model,
+        schema: options.schema,
+        system: prompt.system,
+        user: prompt.user,
+        artifacts: batch,
+        events: options.events,
+        execute: this.config.execute,
+        strict: options.strict ?? this.config.strict,
+        debug,
+        callId: `parallel_auto_batch_${index + 1}`,
+        telemetry: telemetry ?? void 0,
+        parentSpan: strategySpan
+      });
+      step += 1;
+      await options.events?.onStep?.({
+        step,
+        total: totalSteps,
+        label: `batch ${index + 1}/${batches.length}`
+      });
+      debug?.step({
+        step,
+        total: totalSteps,
+        label: `batch ${index + 1}/${batches.length}`,
+        strategy: this.name
+      });
+      return result;
+    });
+    const results = await runConcurrently(
+      tasks,
+      this.config.concurrency ?? batches.length
+    );
+    const merger = new SmartDataMerger(
+      options.schema
+    );
+    let merged = {};
+    debug?.mergeStart({
+      mergeId: "parallel_auto_smart_merge",
+      inputCount: results.length,
+      strategy: this.name
+    });
+    const mergeSpan = telemetry?.startSpan({
+      name: "struktur.smart_merge",
+      kind: "CHAIN",
+      parentSpan: strategySpan,
+      attributes: {
+        "merge.strategy": "smart",
+        "merge.input_count": results.length
+      }
+    });
+    for (let i = 0; i < results.length; i++) {
+      const result = results[i];
+      const prevSize = Object.keys(merged).length;
+      merged = merger.merge(merged, result.data);
+      const newSize = Object.keys(merged).length;
+      for (const key of Object.keys(result.data)) {
+        const leftArray = Array.isArray(merged[key]) ? merged[key].length : void 0;
+        const rightArray = Array.isArray(
+          result.data[key]
+        ) ? result.data[key].length : void 0;
+        debug?.smartMergeField({
+          mergeId: "parallel_auto_smart_merge",
+          field: key,
+          operation: "merge_arrays",
+          leftCount: leftArray,
+          rightCount: rightArray
+        });
+        if (mergeSpan && telemetry) {
+          telemetry.recordEvent(mergeSpan, {
+            type: "merge",
+            strategy: "smart",
+            inputCount: rightArray ?? 1,
+            outputCount: leftArray ?? 1
+          });
+        }
+      }
+    }
+    debug?.mergeComplete({
+      mergeId: "parallel_auto_smart_merge",
+      success: true
+    });
+    if (mergeSpan && telemetry) {
+      telemetry.endSpan(mergeSpan, {
+        status: "ok",
+        output: merged
+      });
+    }
+    merged = dedupeArrays(merged);
+    const exactDedupeSpan = telemetry?.startSpan({
+      name: "struktur.exact_dedupe",
+      kind: "CHAIN",
+      parentSpan: strategySpan,
+      attributes: {
+        "dedupe.method": "exact_hashing"
+      }
+    });
+    if (exactDedupeSpan && telemetry) {
+      telemetry.recordEvent(exactDedupeSpan, {
+        type: "merge",
+        strategy: "exact_hash_dedupe",
+        inputCount: Object.keys(merged).length,
+        outputCount: Object.keys(merged).length
+      });
+      telemetry.endSpan(exactDedupeSpan, {
+        status: "ok",
+        output: merged
+      });
+    }
+    const dedupePrompt = buildDeduplicationPrompt(schema, merged);
+    debug?.dedupeStart({
+      dedupeId: "parallel_auto_dedupe",
+      itemCount: Object.keys(merged).length
+    });
+    const llmDedupeSpan = telemetry?.startSpan({
+      name: "struktur.llm_dedupe",
+      kind: "CHAIN",
+      parentSpan: strategySpan,
+      attributes: {
+        "dedupe.method": "llm"
+      }
+    });
+    const dedupeResponse = await runWithRetries({
+      model: this.config.dedupeModel ?? this.config.model,
+      schema: dedupeSchema,
+      system: dedupePrompt.system,
+      user: dedupePrompt.user,
+      events: options.events,
+      execute: this.config.dedupeExecute,
+      strict: this.config.strict,
+      debug,
+      callId: "parallel_auto_dedupe",
+      telemetry: telemetry ?? void 0,
+      parentSpan: llmDedupeSpan
+    });
+    step += 1;
+    await options.events?.onStep?.({
+      step,
+      total: totalSteps,
+      label: "dedupe"
+    });
+    debug?.step({
+      step,
+      total: totalSteps,
+      label: "dedupe",
+      strategy: this.name
+    });
+    let deduped = merged;
+    for (const key of dedupeResponse.data.keys) {
+      deduped = removeByPath(deduped, key);
+    }
+    debug?.dedupeComplete({
+      dedupeId: "parallel_auto_dedupe",
+      duplicatesFound: dedupeResponse.data.keys.length,
+      itemsRemoved: dedupeResponse.data.keys.length
+    });
+    if (llmDedupeSpan && telemetry) {
+      telemetry.recordEvent(llmDedupeSpan, {
+        type: "merge",
+        strategy: "llm_dedupe",
+        inputCount: Object.keys(merged).length,
+        outputCount: Object.keys(deduped).length,
+        deduped: dedupeResponse.data.keys.length
+      });
+      telemetry.endSpan(llmDedupeSpan, {
+        status: "ok",
+        output: deduped
+      });
+    }
+    telemetry?.endSpan(strategySpan, {
+      status: "ok",
+      output: deduped
+    });
+    return {
+      data: deduped,
+      usage: mergeUsage([...results.map((r) => r.usage), dedupeResponse.usage])
+    };
+  }
+};
+var parallelAutoMerge = (config) => {
+  return new ParallelAutoMergeStrategy(config);
+};
+
+// src/strategies/SequentialAutoMergeStrategy.ts
+var dedupeSchema2 = {
+  type: "object",
+  properties: {
+    keys: { type: "array", items: { type: "string" } }
+  },
+  required: ["keys"],
+  additionalProperties: false
+};
+var dedupeArrays2 = (data) => {
+  const result = { ...data };
+  for (const [key, value] of Object.entries(result)) {
+    if (Array.isArray(value)) {
+      const duplicates = findExactDuplicatesWithHashing(value);
+      result[key] = deduplicateByIndices(value, duplicates);
+    }
+  }
+  return result;
+};
+var removeByPath2 = (data, path5) => {
+  const [root, indexStr] = path5.split(".");
+  const index = Number(indexStr);
+  if (!root || Number.isNaN(index)) {
+    return data;
+  }
+  const value = data[root];
+  if (!Array.isArray(value)) {
+    return data;
+  }
+  const next = [...value];
+  next.splice(index, 1);
+  return { ...data, [root]: next };
+};
+var SequentialAutoMergeStrategy = class {
+  name = "sequential-auto-merge";
+  config;
+  constructor(config) {
+    this.config = config;
+  }
+  getEstimatedSteps(artifacts) {
+    const batches = getBatches(artifacts, {
+      maxTokens: this.config.chunkSize,
+      maxImages: this.config.maxImages
+    });
+    return batches.length + 3;
+  }
+  async run(options) {
+    const debug = options.debug;
+    const { telemetry } = options;
+    const strategySpan = telemetry?.startSpan({
+      name: "strategy.sequential-auto-merge",
+      kind: "CHAIN",
+      attributes: {
+        "strategy.name": this.name,
+        "strategy.artifacts.count": options.artifacts.length,
+        "strategy.chunk_size": this.config.chunkSize
+      }
+    });
+    const batches = getBatches(
+      options.artifacts,
+      {
+        maxTokens: this.config.chunkSize,
+        maxImages: this.config.maxImages
+      },
+      debug,
+      telemetry ?? void 0,
+      strategySpan
+    );
+    const schema = serializeSchema(options.schema);
+    const merger = new SmartDataMerger(
+      options.schema
+    );
+    let merged = {};
+    const usages = [];
+    const totalSteps = this.getEstimatedSteps(options.artifacts);
+    let step = 1;
+    debug?.mergeStart({
+      mergeId: "sequential_auto_merge",
+      inputCount: batches.length,
+      strategy: this.name
+    });
+    const mergeSpan = telemetry?.startSpan({
+      name: "struktur.smart_merge",
+      kind: "CHAIN",
+      parentSpan: strategySpan,
+      attributes: {
+        "merge.strategy": "smart",
+        "merge.input_count": batches.length
+      }
+    });
+    for (const [index, batch] of batches.entries()) {
+      const prompt = buildExtractorPrompt(
+        batch,
+        schema,
+        this.config.outputInstructions
+      );
+      const result = await extractWithPrompt({
+        model: this.config.model,
+        schema: options.schema,
+        system: prompt.system,
+        user: prompt.user,
+        artifacts: batch,
+        events: options.events,
+        execute: this.config.execute,
+        strict: options.strict ?? this.config.strict,
+        debug,
+        callId: `sequential_auto_batch_${index + 1}`,
+        telemetry: telemetry ?? void 0,
+        parentSpan: mergeSpan
+      });
+      merged = merger.merge(merged, result.data);
+      usages.push(result.usage);
+      for (const key of Object.keys(result.data)) {
+        const leftArray = Array.isArray(merged[key]) ? merged[key].length : void 0;
+        const rightArray = Array.isArray(
+          result.data[key]
+        ) ? result.data[key].length : void 0;
+        debug?.smartMergeField({
+          mergeId: "sequential_auto_merge",
+          field: key,
+          operation: "merge_arrays",
+          leftCount: leftArray,
+          rightCount: rightArray
+        });
+        if (mergeSpan && telemetry) {
+          telemetry.recordEvent(mergeSpan, {
+            type: "merge",
+            strategy: "smart",
+            inputCount: rightArray ?? 1,
+            outputCount: leftArray ?? 1
+          });
+        }
+      }
+      step += 1;
+      await options.events?.onStep?.({
+        step,
+        total: totalSteps,
+        label: `batch ${index + 1}/${batches.length}`
+      });
+      debug?.step({
+        step,
+        total: totalSteps,
+        label: `batch ${index + 1}/${batches.length}`,
+        strategy: this.name
+      });
+    }
+    debug?.mergeComplete({ mergeId: "sequential_auto_merge", success: true });
+    if (mergeSpan && telemetry) {
+      telemetry.endSpan(mergeSpan, {
+        status: "ok",
+        output: merged
+      });
+    }
+    merged = dedupeArrays2(merged);
+    const exactDedupeSpan = telemetry?.startSpan({
+      name: "struktur.exact_dedupe",
+      kind: "CHAIN",
+      parentSpan: strategySpan,
+      attributes: {
+        "dedupe.method": "exact_hashing"
+      }
+    });
+    if (exactDedupeSpan && telemetry) {
+      telemetry.recordEvent(exactDedupeSpan, {
+        type: "merge",
+        strategy: "exact_hash_dedupe",
+        inputCount: Object.keys(merged).length,
+        outputCount: Object.keys(merged).length
+      });
+      telemetry.endSpan(exactDedupeSpan, {
+        status: "ok",
+        output: merged
+      });
+    }
+    const dedupePrompt = buildDeduplicationPrompt(schema, merged);
+    debug?.dedupeStart({
+      dedupeId: "sequential_auto_dedupe",
+      itemCount: Object.keys(merged).length
+    });
+    const llmDedupeSpan = telemetry?.startSpan({
+      name: "struktur.llm_dedupe",
+      kind: "CHAIN",
+      parentSpan: strategySpan,
+      attributes: {
+        "dedupe.method": "llm"
+      }
+    });
+    const dedupeResponse = await runWithRetries({
+      model: this.config.dedupeModel ?? this.config.model,
+      schema: dedupeSchema2,
+      system: dedupePrompt.system,
+      user: dedupePrompt.user,
+      events: options.events,
+      execute: this.config.dedupeExecute,
+      strict: this.config.strict,
+      debug,
+      callId: "sequential_auto_dedupe",
+      telemetry: telemetry ?? void 0,
+      parentSpan: llmDedupeSpan
+    });
+    step += 1;
+    await options.events?.onStep?.({
+      step,
+      total: totalSteps,
+      label: "dedupe"
+    });
+    debug?.step({
+      step,
+      total: totalSteps,
+      label: "dedupe",
+      strategy: this.name
+    });
+    let deduped = merged;
+    for (const key of dedupeResponse.data.keys) {
+      deduped = removeByPath2(deduped, key);
+    }
+    debug?.dedupeComplete({
+      dedupeId: "sequential_auto_dedupe",
+      duplicatesFound: dedupeResponse.data.keys.length,
+      itemsRemoved: dedupeResponse.data.keys.length
+    });
+    if (llmDedupeSpan && telemetry) {
+      telemetry.recordEvent(llmDedupeSpan, {
+        type: "merge",
+        strategy: "llm_dedupe",
+        inputCount: Object.keys(merged).length,
+        outputCount: Object.keys(deduped).length,
+        deduped: dedupeResponse.data.keys.length
+      });
+      telemetry.endSpan(llmDedupeSpan, {
+        status: "ok",
+        output: deduped
+      });
+    }
+    telemetry?.endSpan(strategySpan, {
+      status: "ok",
+      output: deduped
+    });
+    return {
+      data: deduped,
+      usage: mergeUsage([...usages, dedupeResponse.usage])
+    };
+  }
+};
+var sequentialAutoMerge = (config) => {
+  return new SequentialAutoMergeStrategy(config);
+};
+
+// src/strategies/DoublePassStrategy.ts
+var DoublePassStrategy = class {
+  name = "double-pass";
+  config;
+  constructor(config) {
+    this.config = config;
+  }
+  getEstimatedSteps(artifacts) {
+    const batches = getBatches(artifacts, {
+      maxTokens: this.config.chunkSize,
+      maxImages: this.config.maxImages
+    });
+    return batches.length * 2 + 3;
+  }
+  async run(options) {
+    const debug = options.debug;
+    const { telemetry } = options;
+    const strategySpan = telemetry?.startSpan({
+      name: "strategy.double-pass",
+      kind: "CHAIN",
+      attributes: {
+        "strategy.name": this.name,
+        "strategy.artifacts.count": options.artifacts.length,
+        "strategy.chunk_size": this.config.chunkSize,
+        "strategy.concurrency": this.config.concurrency
+      }
+    });
+    const batches = getBatches(
+      options.artifacts,
+      {
+        maxTokens: this.config.chunkSize,
+        maxImages: this.config.maxImages
+      },
+      debug,
+      telemetry ?? void 0,
+      strategySpan
+    );
+    const schema = serializeSchema(options.schema);
+    const totalSteps = this.getEstimatedSteps(options.artifacts);
+    let step = 1;
+    const pass1Span = telemetry?.startSpan({
+      name: "struktur.pass_1",
+      kind: "CHAIN",
+      parentSpan: strategySpan,
+      attributes: {
+        "pass.number": 1,
+        "pass.type": "parallel_extraction"
+      }
+    });
+    const tasks = batches.map((batch, index) => async () => {
+      const prompt = buildExtractorPrompt(
+        batch,
+        schema,
+        this.config.outputInstructions
+      );
+      const result = await extractWithPrompt({
+        model: this.config.model,
+        schema: options.schema,
+        system: prompt.system,
+        user: prompt.user,
+        artifacts: batch,
+        events: options.events,
+        execute: this.config.execute,
+        strict: options.strict ?? this.config.strict,
+        debug,
+        callId: `double_pass_1_batch_${index + 1}`,
+        telemetry: telemetry ?? void 0,
+        parentSpan: pass1Span
+      });
+      step += 1;
+      await options.events?.onStep?.({
+        step,
+        total: totalSteps,
+        label: `pass 1 batch ${index + 1}/${batches.length}`
+      });
+      debug?.step({
+        step,
+        total: totalSteps,
+        label: `pass 1 batch ${index + 1}/${batches.length}`,
+        strategy: this.name
+      });
+      return result;
+    });
+    const results = await runConcurrently(
+      tasks,
+      this.config.concurrency ?? batches.length
+    );
+    debug?.mergeStart({
+      mergeId: "double_pass_1_merge",
+      inputCount: results.length,
+      strategy: this.name
+    });
+    const pass1MergeSpan = telemetry?.startSpan({
+      name: "struktur.pass_1_merge",
+      kind: "CHAIN",
+      parentSpan: pass1Span,
+      attributes: {
+        "merge.strategy": "parallel",
+        "merge.input_count": results.length
+      }
+    });
+    const mergePrompt = buildParallelMergerPrompt(
+      schema,
+      results.map((r) => r.data)
+    );
+    const merged = await extractWithPrompt({
+      model: this.config.mergeModel,
+      schema: options.schema,
+      system: mergePrompt.system,
+      user: mergePrompt.user,
+      artifacts: [],
+      events: options.events,
+      execute: this.config.execute,
+      strict: this.config.strict,
+      debug,
+      callId: "double_pass_1_merge",
+      telemetry: telemetry ?? void 0,
+      parentSpan: pass1MergeSpan
+    });
+    step += 1;
+    await options.events?.onStep?.({
+      step,
+      total: totalSteps,
+      label: "pass 1 merge"
+    });
+    debug?.step({
+      step,
+      total: totalSteps,
+      label: "pass 1 merge",
+      strategy: this.name
+    });
+    debug?.mergeComplete({ mergeId: "double_pass_1_merge", success: true });
+    if (pass1MergeSpan && telemetry) {
+      telemetry.recordEvent(pass1MergeSpan, {
+        type: "merge",
+        strategy: "parallel",
+        inputCount: results.length,
+        outputCount: 1
+      });
+      telemetry.endSpan(pass1MergeSpan, {
+        status: "ok",
+        output: merged.data
+      });
+    }
+    telemetry?.endSpan(pass1Span, {
+      status: "ok",
+      output: merged.data
+    });
+    const pass2Span = telemetry?.startSpan({
+      name: "struktur.pass_2",
+      kind: "CHAIN",
+      parentSpan: strategySpan,
+      attributes: {
+        "pass.number": 2,
+        "pass.type": "sequential_refinement"
+      }
+    });
+    let currentData = merged.data;
+    const usages = [...results.map((r) => r.usage), merged.usage];
+    for (const [index, batch] of batches.entries()) {
+      const prompt = buildSequentialPrompt(
+        batch,
+        schema,
+        JSON.stringify(currentData),
+        this.config.outputInstructions
+      );
+      const result = await extractWithPrompt({
+        model: this.config.model,
+        schema: options.schema,
+        system: prompt.system,
+        user: prompt.user,
+        artifacts: batch,
+        events: options.events,
+        execute: this.config.execute,
+        strict: this.config.strict,
+        debug,
+        callId: `double_pass_2_batch_${index + 1}`,
+        telemetry: telemetry ?? void 0,
+        parentSpan: pass2Span
+      });
+      currentData = result.data;
+      usages.push(result.usage);
+      step += 1;
+      await options.events?.onStep?.({
+        step,
+        total: totalSteps,
+        label: `pass 2 batch ${index + 1}/${batches.length}`
+      });
+      debug?.step({
+        step,
+        total: totalSteps,
+        label: `pass 2 batch ${index + 1}/${batches.length}`,
+        strategy: this.name
+      });
+    }
+    telemetry?.endSpan(pass2Span, {
+      status: "ok",
+      output: currentData
+    });
+    telemetry?.endSpan(strategySpan, {
+      status: "ok",
+      output: currentData
+    });
+    return { data: currentData, usage: mergeUsage(usages) };
+  }
+};
+var doublePass = (config) => {
+  return new DoublePassStrategy(config);
+};
+
+// src/strategies/DoublePassAutoMergeStrategy.ts
+var dedupeSchema3 = {
+  type: "object",
+  properties: {
+    keys: { type: "array", items: { type: "string" } }
+  },
+  required: ["keys"],
+  additionalProperties: false
+};
+var dedupeArrays3 = (data) => {
+  const result = { ...data };
+  for (const [key, value] of Object.entries(result)) {
+    if (Array.isArray(value)) {
+      const duplicates = findExactDuplicatesWithHashing(value);
+      result[key] = deduplicateByIndices(value, duplicates);
+    }
+  }
+  return result;
+};
+var removeByPath3 = (data, path5) => {
+  const [root, indexStr] = path5.split(".");
+  const index = Number(indexStr);
+  if (!root || Number.isNaN(index)) {
+    return data;
+  }
+  const value = data[root];
+  if (!Array.isArray(value)) {
+    return data;
+  }
+  const next = [...value];
+  next.splice(index, 1);
+  return { ...data, [root]: next };
+};
+var DoublePassAutoMergeStrategy = class {
+  name = "double-pass-auto-merge";
+  config;
+  constructor(config) {
+    this.config = config;
+  }
+  getEstimatedSteps(artifacts) {
+    const batches = getBatches(artifacts, {
+      maxTokens: this.config.chunkSize,
+      maxImages: this.config.maxImages
+    });
+    return batches.length * 2 + 3;
+  }
+  async run(options) {
+    const debug = options.debug;
+    const { telemetry } = options;
+    const strategySpan = telemetry?.startSpan({
+      name: "strategy.double-pass-auto-merge",
+      kind: "CHAIN",
+      attributes: {
+        "strategy.name": this.name,
+        "strategy.artifacts.count": options.artifacts.length,
+        "strategy.chunk_size": this.config.chunkSize,
+        "strategy.concurrency": this.config.concurrency
+      }
+    });
+    const batches = getBatches(
+      options.artifacts,
+      {
+        maxTokens: this.config.chunkSize,
+        maxImages: this.config.maxImages
+      },
+      debug,
+      telemetry ?? void 0,
+      strategySpan
+    );
+    const schema = serializeSchema(options.schema);
+    const totalSteps = this.getEstimatedSteps(options.artifacts);
+    let step = 1;
+    const pass1Span = telemetry?.startSpan({
+      name: "struktur.pass_1",
+      kind: "CHAIN",
+      parentSpan: strategySpan,
+      attributes: {
+        "pass.number": 1,
+        "pass.type": "parallel_extraction"
+      }
+    });
+    const tasks = batches.map((batch, index) => async () => {
+      const prompt = buildExtractorPrompt(
+        batch,
+        schema,
+        this.config.outputInstructions
+      );
+      const result = await extractWithPrompt({
+        model: this.config.model,
+        schema: options.schema,
+        system: prompt.system,
+        user: prompt.user,
+        artifacts: batch,
+        events: options.events,
+        execute: this.config.execute,
+        strict: options.strict ?? this.config.strict,
+        debug,
+        callId: `double_pass_auto_1_batch_${index + 1}`,
+        telemetry: telemetry ?? void 0,
+        parentSpan: pass1Span
+      });
+      step += 1;
+      await options.events?.onStep?.({
+        step,
+        total: totalSteps,
+        label: `pass 1 batch ${index + 1}/${batches.length}`
+      });
+      debug?.step({
+        step,
+        total: totalSteps,
+        label: `pass 1 batch ${index + 1}/${batches.length}`,
+        strategy: this.name
+      });
+      return result;
+    });
+    const results = await runConcurrently(
+      tasks,
+      this.config.concurrency ?? batches.length
+    );
+    const merger = new SmartDataMerger(
+      options.schema
+    );
+    let merged = {};
+    debug?.mergeStart({
+      mergeId: "double_pass_auto_merge",
+      inputCount: results.length,
+      strategy: this.name
+    });
+    const mergeSpan = telemetry?.startSpan({
+      name: "struktur.smart_merge",
+      kind: "CHAIN",
+      parentSpan: pass1Span,
+      attributes: {
+        "merge.strategy": "smart",
+        "merge.input_count": results.length
+      }
+    });
+    for (let i = 0; i < results.length; i++) {
+      const result = results[i];
+      merged = merger.merge(merged, result.data);
+      for (const key of Object.keys(result.data)) {
+        const leftArray = Array.isArray(merged[key]) ? merged[key].length : void 0;
+        const rightArray = Array.isArray(
+          result.data[key]
+        ) ? result.data[key].length : void 0;
+        debug?.smartMergeField({
+          mergeId: "double_pass_auto_merge",
+          field: key,
+          operation: "merge_arrays",
+          leftCount: leftArray,
+          rightCount: rightArray
+        });
+        if (mergeSpan && telemetry) {
+          telemetry.recordEvent(mergeSpan, {
+            type: "merge",
+            strategy: "smart",
+            inputCount: rightArray ?? 1,
+            outputCount: leftArray ?? 1
+          });
+        }
+      }
+    }
+    debug?.mergeComplete({ mergeId: "double_pass_auto_merge", success: true });
+    if (mergeSpan && telemetry) {
+      telemetry.endSpan(mergeSpan, {
+        status: "ok",
+        output: merged
+      });
+    }
+    merged = dedupeArrays3(merged);
+    const exactDedupeSpan = telemetry?.startSpan({
+      name: "struktur.exact_dedupe",
+      kind: "CHAIN",
+      parentSpan: pass1Span,
+      attributes: {
+        "dedupe.method": "exact_hashing"
+      }
+    });
+    if (exactDedupeSpan && telemetry) {
+      telemetry.recordEvent(exactDedupeSpan, {
+        type: "merge",
+        strategy: "exact_hash_dedupe",
+        inputCount: Object.keys(merged).length,
+        outputCount: Object.keys(merged).length
+      });
+      telemetry.endSpan(exactDedupeSpan, {
+        status: "ok",
+        output: merged
+      });
+    }
+    const dedupePrompt = buildDeduplicationPrompt(schema, merged);
+    debug?.dedupeStart({
+      dedupeId: "double_pass_auto_dedupe",
+      itemCount: Object.keys(merged).length
+    });
+    const llmDedupeSpan = telemetry?.startSpan({
+      name: "struktur.llm_dedupe",
+      kind: "CHAIN",
+      parentSpan: pass1Span,
+      attributes: {
+        "dedupe.method": "llm"
+      }
+    });
+    const dedupeResponse = await runWithRetries({
+      model: this.config.dedupeModel ?? this.config.model,
+      schema: dedupeSchema3,
+      system: dedupePrompt.system,
+      user: dedupePrompt.user,
+      events: options.events,
+      execute: this.config.dedupeExecute,
+      strict: this.config.strict,
+      debug,
+      callId: "double_pass_auto_dedupe",
+      telemetry: telemetry ?? void 0,
+      parentSpan: llmDedupeSpan
+    });
+    step += 1;
+    await options.events?.onStep?.({
+      step,
+      total: totalSteps,
+      label: "pass 1 dedupe"
+    });
+    debug?.step({
+      step,
+      total: totalSteps,
+      label: "pass 1 dedupe",
+      strategy: this.name
+    });
+    let deduped = merged;
+    for (const key of dedupeResponse.data.keys) {
+      deduped = removeByPath3(deduped, key);
+    }
+    debug?.dedupeComplete({
+      dedupeId: "double_pass_auto_dedupe",
+      duplicatesFound: dedupeResponse.data.keys.length,
+      itemsRemoved: dedupeResponse.data.keys.length
+    });
+    if (llmDedupeSpan && telemetry) {
+      telemetry.recordEvent(llmDedupeSpan, {
+        type: "merge",
+        strategy: "llm_dedupe",
+        inputCount: Object.keys(merged).length,
+        outputCount: Object.keys(deduped).length,
+        deduped: dedupeResponse.data.keys.length
+      });
+      telemetry.endSpan(llmDedupeSpan, {
+        status: "ok",
+        output: deduped
+      });
+    }
+    telemetry?.endSpan(pass1Span, {
+      status: "ok",
+      output: deduped
+    });
+    let currentData = deduped;
+    const usages = [...results.map((r) => r.usage), dedupeResponse.usage];
+    const pass2Span = telemetry?.startSpan({
+      name: "struktur.pass_2",
+      kind: "CHAIN",
+      parentSpan: strategySpan,
+      attributes: {
+        "pass.number": 2,
+        "pass.type": "sequential_refinement"
+      }
+    });
+    for (const [index, batch] of batches.entries()) {
+      const prompt = buildSequentialPrompt(
+        batch,
+        schema,
+        JSON.stringify(currentData),
+        this.config.outputInstructions
+      );
+      const result = await extractWithPrompt({
+        model: this.config.model,
+        schema: options.schema,
+        system: prompt.system,
+        user: prompt.user,
+        artifacts: batch,
+        events: options.events,
+        execute: this.config.execute,
+        strict: this.config.strict,
+        debug,
+        callId: `double_pass_auto_2_batch_${index + 1}`,
+        telemetry: telemetry ?? void 0,
+        parentSpan: pass2Span
+      });
+      currentData = result.data;
+      usages.push(result.usage);
+      step += 1;
+      await options.events?.onStep?.({
+        step,
+        total: totalSteps,
+        label: `pass 2 batch ${index + 1}/${batches.length}`
+      });
+      debug?.step({
+        step,
+        total: totalSteps,
+        label: `pass 2 batch ${index + 1}/${batches.length}`,
+        strategy: this.name
+      });
+    }
+    telemetry?.endSpan(pass2Span, {
+      status: "ok",
+      output: currentData
+    });
+    telemetry?.endSpan(strategySpan, {
+      status: "ok",
+      output: currentData
+    });
+    return { data: currentData, usage: mergeUsage(usages) };
+  }
+};
+var doublePassAutoMerge = (config) => {
+  return new DoublePassAutoMergeStrategy(config);
+};
+
+// src/index.ts
+init_collect();
+init_pdf();
+import { AgentStrategy, agent } from "@struktur/agent-strategy";
+
+// src/debug/logger.ts
+var createDebugLogger = (enabled) => {
+  const log = (entry) => {
+    if (!enabled) return;
+    const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+    const logEntry = { timestamp, ...entry };
+    process.stderr.write(JSON.stringify(logEntry) + "\n");
+  };
+  return {
+    // CLI initialization
+    cliInit: (data) => {
+      log({ type: "cli_init", ...data });
+    },
+    schemaLoaded: (data) => {
+      log({ type: "schema_loaded", ...data });
+    },
+    artifactsLoaded: (data) => {
+      log({ type: "artifacts_loaded", ...data });
+    },
+    modelResolved: (data) => {
+      log({ type: "model_resolved", ...data });
+    },
+    strategyCreated: (data) => {
+      log({ type: "strategy_created", ...data });
+    },
+    // Chunking
+    chunkingStart: (data) => {
+      log({ type: "chunking_start", ...data });
+    },
+    chunkingSplit: (data) => {
+      log({ type: "chunking_split", ...data });
+    },
+    chunkingResult: (data) => {
+      log({ type: "chunking_result", ...data });
+    },
+    batchingStart: (data) => {
+      log({ type: "batching_start", ...data });
+    },
+    batchCreated: (data) => {
+      log({ type: "batch_created", ...data });
+    },
+    batchingComplete: (data) => {
+      log({ type: "batching_complete", ...data });
+    },
+    // Strategy execution
+    strategyRunStart: (data) => {
+      log({ type: "strategy_run_start", ...data });
+    },
+    step: (data) => {
+      log({ type: "step", ...data });
+    },
+    progress: (data) => {
+      log({ type: "progress", ...data });
+    },
+    // LLM calls
+    llmCallStart: (data) => {
+      log({ type: "llm_call_start", ...data });
+    },
+    llmCallComplete: (data) => {
+      log({ type: "llm_call_complete", ...data });
+    },
+    // Retry events
+    retry: (data) => {
+      log({ type: "retry", ...data });
+    },
+    // Validation
+    validationStart: (data) => {
+      log({ type: "validation_start", ...data });
+    },
+    validationSuccess: (data) => {
+      log({ type: "validation_success", ...data });
+    },
+    validationFailed: (data) => {
+      log({ type: "validation_failed", ...data });
+    },
+    // Merging
+    mergeStart: (data) => {
+      log({ type: "merge_start", ...data });
+    },
+    mergeComplete: (data) => {
+      log({ type: "merge_complete", ...data });
+    },
+    // Deduplication
+    dedupeStart: (data) => {
+      log({ type: "dedupe_start", ...data });
+    },
+    dedupeComplete: (data) => {
+      log({ type: "dedupe_complete", ...data });
+    },
+    // Token usage tracking
+    tokenUsage: (data) => {
+      log({ type: "token_usage", ...data });
+    },
+    // Results
+    extractionComplete: (data) => {
+      log({ type: "extraction_complete", ...data });
+    },
+    // Prompt details (verbose)
+    promptSystem: (data) => {
+      log({ type: "prompt_system", ...data });
+    },
+    promptUser: (data) => {
+      log({ type: "prompt_user", ...data });
+    },
+    // Raw response
+    rawResponse: (data) => {
+      log({ type: "raw_response", ...data });
+    },
+    // Smart merge details
+    smartMergeField: (data) => {
+      log({ type: "smart_merge_field", ...data });
+    }
+  };
+};
+
+// src/auth/tokens.ts
+import path3 from "path";
+import os2 from "os";
+import { chmod, mkdir, readFile as readFile3, writeFile as writeFile2, stat, access } from "fs/promises";
+import { execFile } from "child_process";
+import { promisify as promisify2 } from "util";
+var execFileAsync = promisify2(execFile);
+var CONFIG_DIR_ENV = "STRUKTUR_CONFIG_DIR";
+var DISABLE_KEYCHAIN_ENV = "STRUKTUR_DISABLE_KEYCHAIN";
+var SERVICE_ENV = "STRUKTUR_KEYCHAIN_SERVICE";
+var DEFAULT_SERVICE = "struktur";
+var resolveConfigDir = () => {
+  return process.env[CONFIG_DIR_ENV] ?? path3.join(os2.homedir(), ".config", "struktur");
+};
+var resolveTokensPath = () => path3.join(resolveConfigDir(), "tokens.json");
+var emptyStore = () => ({ version: 1, providers: {} });
+var readTokenStore = async () => {
+  const tokensPath = resolveTokensPath();
+  try {
+    await stat(tokensPath);
+  } catch {
+    return emptyStore();
+  }
+  const raw = await readFile3(tokensPath, "utf-8");
+  const parsed = JSON.parse(raw);
+  if (!parsed || parsed.version !== 1 || typeof parsed.providers !== "object") {
+    return emptyStore();
+  }
+  return parsed;
+};
+var writeTokenStore = async (store) => {
+  const configDir = resolveConfigDir();
+  const tokensPath = resolveTokensPath();
+  await mkdir(configDir, { recursive: true, mode: 448 });
+  await writeFile2(tokensPath, JSON.stringify(store, null, 2));
+  await chmod(configDir, 448);
+  await chmod(tokensPath, 384);
+};
+var isKeychainAvailable = async () => {
+  if (process.env[DISABLE_KEYCHAIN_ENV]) {
+    return false;
+  }
+  if (process.platform !== "darwin") {
+    return false;
+  }
+  try {
+    await access("/usr/bin/security");
+    return true;
+  } catch {
+    return false;
+  }
+};
+var keychainService = () => process.env[SERVICE_ENV] ?? DEFAULT_SERVICE;
+var runSecurity = async (args) => {
+  try {
+    const { stdout } = await execFileAsync("/usr/bin/security", args);
+    return stdout;
+  } catch (error) {
+    if (error instanceof Error && "stderr" in error) {
+      const stderr = error.stderr;
+      const message = stderr?.trim() || error.message;
+      throw new Error(message);
+    }
+    throw error;
+  }
+};
+var writeKeychainToken = async (provider, token) => {
+  await runSecurity([
+    "add-generic-password",
+    "-a",
+    provider,
+    "-s",
+    keychainService(),
+    "-w",
+    token,
+    "-U"
+  ]);
+};
+var readKeychainToken = async (provider) => {
+  const output = await runSecurity([
+    "find-generic-password",
+    "-a",
+    provider,
+    "-s",
+    keychainService(),
+    "-w"
+  ]);
+  return output.trim();
+};
+var deleteKeychainToken = async (provider) => {
+  await runSecurity([
+    "delete-generic-password",
+    "-a",
+    provider,
+    "-s",
+    keychainService()
+  ]);
+};
+var listStoredProviders = async () => {
+  const store = await readTokenStore();
+  return Object.entries(store.providers).map(([provider, entry]) => ({
+    provider,
+    storage: entry.storage
+  }));
+};
+var setProviderToken = async (provider, token, storage = "auto") => {
+  const store = await readTokenStore();
+  let resolvedStorage = "file";
+  if (storage === "keychain") {
+    if (!await isKeychainAvailable()) {
+      throw new Error("Keychain is not available on this platform.");
+    }
+    resolvedStorage = "keychain";
+  } else if (storage === "auto") {
+    resolvedStorage = await isKeychainAvailable() ? "keychain" : "file";
+  }
+  if (resolvedStorage === "keychain") {
+    await writeKeychainToken(provider, token);
+    store.providers[provider] = {
+      storage: "keychain",
+      account: provider,
+      service: keychainService()
+    };
+  } else {
+    store.providers[provider] = {
+      storage: "file",
+      token
+    };
+  }
+  await writeTokenStore(store);
+  return resolvedStorage;
+};
+var deleteProviderToken = async (provider) => {
+  const store = await readTokenStore();
+  const entry = store.providers[provider];
+  if (!entry) {
+    return false;
+  }
+  if (entry.storage === "keychain") {
+    try {
+      await deleteKeychainToken(provider);
+    } catch {
+    }
+  }
+  delete store.providers[provider];
+  await writeTokenStore(store);
+  return true;
+};
+var resolveProviderToken = async (provider) => {
+  const store = await readTokenStore();
+  const entry = store.providers[provider];
+  if (!entry) {
+    return void 0;
+  }
+  if (entry.storage === "file") {
+    return entry.token;
+  }
+  try {
+    return await readKeychainToken(provider);
+  } catch {
+    return void 0;
+  }
+};
+var getProviderTokenOrThrow = async (provider) => {
+  const token = await resolveProviderToken(provider);
+  if (!token) {
+    throw new Error(`No token stored for provider: ${provider}`);
+  }
+  return token;
+};
+var resolveProviderEnvVar = (provider) => {
+  switch (provider) {
+    case "openai":
+      return "OPENAI_API_KEY";
+    case "anthropic":
+      return "ANTHROPIC_API_KEY";
+    case "google":
+      return "GOOGLE_GENERATIVE_AI_API_KEY";
+    case "opencode":
+      return "OPENCODE_API_KEY";
+    case "openrouter":
+      return "OPENROUTER_API_KEY";
+    default:
+      return void 0;
+  }
+};
+var maskToken = (token) => {
+  if (token.length <= 8) {
+    return "********";
+  }
+  return `${token.slice(0, 4)}...${token.slice(-4)}`;
+};
+
+// src/llm/models.ts
+var openAiModelsUrl = "https://api.openai.com/v1/models";
+var anthropicModelsUrl = "https://api.anthropic.com/v1/models";
+var googleModelsUrl = "https://generativelanguage.googleapis.com/v1beta/models";
+var openRouterModelsUrl = "https://openrouter.ai/api/v1/models";
+var getTokenForProvider = async (provider) => {
+  const envVar = resolveProviderEnvVar(provider);
+  if (envVar && process.env[envVar]) {
+    return process.env[envVar];
+  }
+  return await resolveProviderToken(provider);
+};
+var parseOpenAiModels = (json) => {
+  const data = json?.data ?? [];
+  return data.map((item) => item.id).filter((id) => typeof id === "string");
+};
+var parseAnthropicModels = (json) => {
+  const data = json?.data ?? [];
+  return data.map((item) => item.id).filter((id) => typeof id === "string");
+};
+var parseGoogleModels = (json) => {
+  const data = json?.models ?? [];
+  return data.map((item) => item.name).filter((name) => typeof name === "string").map((name) => name.replace(/^models\//, ""));
+};
+var parseOpenRouterModels = (json) => {
+  const data = json?.data ?? [];
+  return data.map((item) => item.id).filter((id) => typeof id === "string");
+};
+var requestModels = async (provider, token) => {
+  if (provider === "openai") {
+    const response = await fetch(openAiModelsUrl, {
+      headers: { Authorization: `Bearer ${token}` }
+    });
+    if (!response.ok) {
+      throw new Error(await response.text());
+    }
+    const json = await response.json();
+    return parseOpenAiModels(json);
+  }
+  if (provider === "anthropic") {
+    const response = await fetch(anthropicModelsUrl, {
+      headers: {
+        "x-api-key": token,
+        "anthropic-version": "2023-06-01"
+      }
+    });
+    if (!response.ok) {
+      throw new Error(await response.text());
+    }
+    const json = await response.json();
+    return parseAnthropicModels(json);
+  }
+  if (provider === "google") {
+    const response = await fetch(`${googleModelsUrl}?key=${encodeURIComponent(token)}`);
+    if (!response.ok) {
+      throw new Error(await response.text());
+    }
+    const json = await response.json();
+    return parseGoogleModels(json);
+  }
+  if (provider === "openrouter") {
+    const response = await fetch(openRouterModelsUrl, {
+      headers: { Authorization: `Bearer ${token}` }
+    });
+    if (!response.ok) {
+      throw new Error(await response.text());
+    }
+    const json = await response.json();
+    return parseOpenRouterModels(json);
+  }
+  if (provider === "opencode") {
+    return [
+      "gpt-5.2",
+      "gpt-5.2-codex",
+      "gpt-5.1",
+      "gpt-5.1-codex",
+      "gpt-5.1-codex-max",
+      "gpt-5.1-codex-mini",
+      "gpt-5",
+      "gpt-5-codex",
+      "gpt-5-nano",
+      "claude-opus-4-6",
+      "claude-opus-4-5",
+      "claude-opus-4-1",
+      "claude-sonnet-4-6",
+      "claude-sonnet-4-5",
+      "claude-sonnet-4",
+      "claude-haiku-4-5",
+      "claude-haiku-3.5",
+      "gemini-3.1-pro",
+      "gemini-3-pro",
+      "gemini-3-flash",
+      "minimax-m2.5",
+      "minimax-m2.5-free",
+      "minimax-m2.1",
+      "glm-5",
+      "glm-5-free",
+      "glm-4.7",
+      "glm-4.6",
+      "kimi-k2.5",
+      "kimi-k2.5-free",
+      "kimi-k2-thinking",
+      "kimi-k2",
+      "qwen3-coder",
+      "big-pickle"
+    ];
+  }
+  throw new Error(`Unsupported provider: ${provider}`);
+};
+var cheapestModelPreferences = {
+  openai: ["gpt-4.1-nano", "gpt-4.1-mini", "gpt-4o-mini", "gpt-4o"],
+  anthropic: ["claude-3-5-haiku", "claude-3-haiku"],
+  google: ["gemini-1.5-flash-8b", "gemini-1.5-flash", "gemini-2.0-flash", "gemini-1.5-pro"],
+  opencode: ["gpt-5-nano", "claude-haiku-3.5", "gemini-3-flash", "kimi-k2-free", "glm-5-free", "minimax-m2.5-free"],
+  openrouter: ["openai/gpt-4o-mini", "anthropic/claude-3.5-haiku", "google/gemini-flash-1.5"]
+};
+var matchesPreference = (model, preference) => {
+  return model === preference || model.startsWith(`${preference}-`);
+};
+var listProviderModels = async (provider) => {
+  const token = await getTokenForProvider(provider);
+  if (!token) {
+    return { provider, ok: false, error: "No token available" };
+  }
+  try {
+    const models = await requestModels(provider, token);
+    return { provider, ok: true, models };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return { provider, ok: false, error: message };
+  }
+};
+var listAllProviderModels = async (providers) => {
+  const results = await Promise.all(providers.map((provider) => listProviderModels(provider)));
+  return results;
+};
+var pickCheapestModel = (provider, models) => {
+  const preferences = cheapestModelPreferences[provider] ?? [];
+  for (const preference of preferences) {
+    const match = models.find((model) => matchesPreference(model, preference));
+    if (match) {
+      return match;
+    }
+  }
+  return models[0];
+};
+var resolveCheapestModel = async (provider) => {
+  const result = await listProviderModels(provider);
+  if (!result.ok) {
+    throw new Error(result.error ?? `Unable to list models for provider: ${provider}`);
+  }
+  const models = result.models ?? [];
+  const model = pickCheapestModel(provider, models);
+  if (!model) {
+    throw new Error(`No models available for provider: ${provider}`);
+  }
+  return model;
+};
+
+// src/llm/resolveModel.ts
+var resolveModel = async (model) => {
+  globalThis.AI_SDK_LOG_WARNINGS ??= false;
+  process.env.AI_SDK_LOG_WARNINGS ??= "false";
+  const [provider, ...rest] = model.split("/");
+  const modelName = rest.join("/");
+  if (!provider || !modelName) {
+    throw new Error(`Invalid model format: ${model}. Expected format: provider/model (e.g., openai/gpt-4)`);
+  }
+  const envVar = resolveProviderEnvVar(provider);
+  if (envVar && !process.env[envVar]) {
+    const storedToken = await resolveProviderToken(provider);
+    if (storedToken) {
+      process.env[envVar] = storedToken;
+    }
+  }
+  switch (provider) {
+    case "openai": {
+      const { openai } = await import("@ai-sdk/openai");
+      return openai(modelName);
+    }
+    case "anthropic": {
+      const { anthropic } = await import("@ai-sdk/anthropic");
+      return anthropic(modelName);
+    }
+    case "google": {
+      const { google } = await import("@ai-sdk/google");
+      return google(modelName);
+    }
+    case "opencode": {
+      const envVar2 = resolveProviderEnvVar("opencode");
+      let apiKey = envVar2 ? process.env[envVar2] : void 0;
+      if (!apiKey) {
+        apiKey = await resolveProviderToken("opencode");
+      }
+      if (!apiKey) {
+        throw new Error("OpenCode API key is required. Set OPENCODE_API_KEY environment variable or run 'struktur auth set --provider opencode --token <token>'");
+      }
+      if (modelName.startsWith("claude-")) {
+        const { createAnthropic } = await import("@ai-sdk/anthropic");
+        return createAnthropic({
+          apiKey,
+          baseURL: "https://opencode.ai/zen/v1"
+        })(modelName);
+      } else if (modelName.startsWith("gemini-")) {
+        const { createGoogleGenerativeAI } = await import("@ai-sdk/google");
+        return createGoogleGenerativeAI({
+          apiKey,
+          baseURL: "https://opencode.ai/zen/v1"
+        })(modelName);
+      } else {
+        const { createOpenAI } = await import("@ai-sdk/openai");
+        return createOpenAI({
+          apiKey,
+          baseURL: "https://opencode.ai/zen/v1"
+        })(modelName);
+      }
+    }
+    case "openrouter": {
+      const { openrouter } = await import("@openrouter/ai-sdk-provider");
+      const hashIndex = modelName.indexOf("#");
+      const actualModelName = hashIndex >= 0 ? modelName.slice(0, hashIndex) : modelName;
+      const preferredProvider = hashIndex >= 0 ? modelName.slice(hashIndex + 1) : void 0;
+      const modelInstance = openrouter(actualModelName);
+      if (preferredProvider) {
+        Object.defineProperty(modelInstance, "__openrouter_provider", {
+          value: preferredProvider,
+          writable: false,
+          enumerable: false,
+          configurable: false
+        });
+      }
+      return modelInstance;
+    }
+    default:
+      throw new Error(`Unsupported model provider: ${provider}. Supported providers: openai, anthropic, google, opencode, openrouter`);
+  }
+};
+
+// src/auth/config.ts
+import path4 from "path";
+import os3 from "os";
+import { chmod as chmod2, mkdir as mkdir2, readFile as readFile4, writeFile as writeFile3, stat as stat2 } from "fs/promises";
+var CONFIG_DIR_ENV2 = "STRUKTUR_CONFIG_DIR";
+var resolveConfigDir2 = () => {
+  return process.env[CONFIG_DIR_ENV2] ?? path4.join(os3.homedir(), ".config", "struktur");
+};
+var resolveConfigPath = () => path4.join(resolveConfigDir2(), "config.json");
+var emptyStore2 = () => ({ version: 1 });
+var readConfigStore = async () => {
+  const configPath = resolveConfigPath();
+  try {
+    await stat2(configPath);
+  } catch {
+    return emptyStore2();
+  }
+  const raw = await readFile4(configPath, "utf-8");
+  const parsed = JSON.parse(raw);
+  if (!parsed || parsed.version !== 1) {
+    return emptyStore2();
+  }
+  return parsed;
+};
+var writeConfigStore = async (store) => {
+  const configDir = resolveConfigDir2();
+  const configPath = resolveConfigPath();
+  await mkdir2(configDir, { recursive: true, mode: 448 });
+  await writeFile3(configPath, JSON.stringify(store, null, 2));
+  await chmod2(configDir, 448);
+  await chmod2(configPath, 384);
+};
+var getDefaultModel = async () => {
+  const store = await readConfigStore();
+  return store.defaultModel;
+};
+var setDefaultModel = async (model) => {
+  const store = await readConfigStore();
+  store.defaultModel = model;
+  await writeConfigStore(store);
+  return model;
+};
+var listAliases = async () => {
+  const store = await readConfigStore();
+  return store.aliases ?? {};
+};
+var getAlias = async (alias) => {
+  const store = await readConfigStore();
+  return store.aliases?.[alias];
+};
+var setAlias = async (alias, model) => {
+  const store = await readConfigStore();
+  store.aliases ??= {};
+  store.aliases[alias] = model;
+  await writeConfigStore(store);
+  return model;
+};
+var deleteAlias = async (alias) => {
+  const store = await readConfigStore();
+  if (!store.aliases?.[alias]) {
+    return false;
+  }
+  delete store.aliases[alias];
+  await writeConfigStore(store);
+  return true;
+};
+var resolveAlias = async (modelSpec) => {
+  const aliases = await listAliases();
+  return aliases[modelSpec] ?? modelSpec;
+};
+var listParsers = async () => {
+  const store = await readConfigStore();
+  return store.parsers ?? {};
+};
+var getParser = async (mimeType) => {
+  const store = await readConfigStore();
+  return store.parsers?.[mimeType];
+};
+var setParser = async (mimeType, def) => {
+  if (def.type === "command-file" && !def.command.includes("FILE_PATH")) {
+    throw new Error(
+      `command-file parser must contain FILE_PATH placeholder in the command string. Got: "${def.command}"`
+    );
+  }
+  const store = await readConfigStore();
+  store.parsers ??= {};
+  store.parsers[mimeType] = def;
+  await writeConfigStore(store);
+};
+var deleteParser = async (mimeType) => {
+  const store = await readConfigStore();
+  if (!store.parsers?.[mimeType]) {
+    return false;
+  }
+  delete store.parsers[mimeType];
+  await writeConfigStore(store);
+  return true;
+};
+var getTelemetryConfig = async () => {
+  const store = await readConfigStore();
+  return store.telemetry;
+};
+var setTelemetryConfig = async (config) => {
+  const store = await readConfigStore();
+  store.telemetry = config;
+  await writeConfigStore(store);
+};
+var enableTelemetry = async (provider, options) => {
+  const store = await readConfigStore();
+  store.telemetry = {
+    enabled: true,
+    provider,
+    ...options
+  };
+  await writeConfigStore(store);
+};
+var disableTelemetry = async () => {
+  const store = await readConfigStore();
+  if (store.telemetry) {
+    store.telemetry.enabled = false;
+  }
+  await writeConfigStore(store);
+};
+var deleteTelemetryConfig = async () => {
+  const store = await readConfigStore();
+  if (!store.telemetry) {
+    return false;
+  }
+  delete store.telemetry;
+  await writeConfigStore(store);
+  return true;
+};
+export {
+  AgentStrategy,
+  DoublePassAutoMergeStrategy,
+  DoublePassStrategy,
+  ParallelAutoMergeStrategy,
+  ParallelStrategy,
+  SchemaValidationError,
+  SequentialAutoMergeStrategy,
+  SequentialStrategy,
+  SimpleStrategy,
+  agent,
+  buildSchemaFromFields,
+  buildSchemaFromParsedFields,
+  clearArtifactInputParsers,
+  collectStream,
+  createDebugLogger,
+  defaultArtifactProviders,
+  deleteAlias,
+  deleteParser,
+  deleteProviderToken,
+  deleteTelemetryConfig,
+  detectMimeType,
+  disableTelemetry,
+  doublePass,
+  doublePassAutoMerge,
+  enableTelemetry,
+  extract,
+  fileToArtifact,
+  getAlias,
+  getDefaultModel,
+  getParser,
+  getProviderTokenOrThrow,
+  getTelemetryConfig,
+  hydrateSerializedArtifacts,
+  listAliases,
+  listAllProviderModels,
+  listParsers,
+  listProviderModels,
+  listStoredProviders,
+  maskToken,
+  parallel,
+  parallelAutoMerge,
+  parse,
+  parseFieldsString,
+  parsePdf,
+  parseSerializedArtifacts,
+  registerArtifactInputParser,
+  resolveAlias,
+  resolveCheapestModel,
+  resolveModel,
+  resolveProviderEnvVar,
+  resolveProviderToken,
+  runParser,
+  sequential,
+  sequentialAutoMerge,
+  setAlias,
+  setDefaultModel,
+  setParser,
+  setProviderToken,
+  setTelemetryConfig,
+  simple,
+  splitTextIntoContents,
+  urlToArtifact,
+  validateSerializedArtifacts
+};
+//# sourceMappingURL=index.js.map