@struktur/sdk 2.1.1 → 2.2.0

package/dist/strategies.js

@@ -0,0 +1,2435 @@
+// 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/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/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, path) => {
+  const [root, indexStr] = path.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, path) => {
+  const [root, indexStr] = path.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, path) => {
+  const [root, indexStr] = path.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);
+};
+export {
+  DoublePassAutoMergeStrategy,
+  DoublePassStrategy,
+  ParallelAutoMergeStrategy,
+  ParallelStrategy,
+  SequentialAutoMergeStrategy,
+  SequentialStrategy,
+  SimpleStrategy,
+  doublePass,
+  doublePassAutoMerge,
+  parallel,
+  parallelAutoMerge,
+  sequential,
+  sequentialAutoMerge,
+  simple
+};
+//# sourceMappingURL=strategies.js.map