@struktur/sdk 2.1.2 → 2.3.0

package/dist/strategies.js

@@ -0,0 +1,3930 @@
+// 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);
+};
+
+// src/strategies/agent/AgentStrategy.ts
+import {
+  createAgentSession,
+  AuthStorage,
+  ModelRegistry,
+  SessionManager,
+  SettingsManager,
+  DefaultResourceLoader
+} from "@mariozechner/pi-coding-agent";
+import { Bash as Bash2 } from "just-bash";
+
+// src/strategies/agent/ArtifactFilesystem.ts
+var detectImageFormat = (base64) => {
+  if (base64.startsWith("/9j/")) {
+    return "jpg";
+  }
+  if (base64.startsWith("iVBOR")) {
+    return "png";
+  }
+  if (base64.startsWith("R0lGOD")) {
+    return "gif";
+  }
+  if (base64.startsWith("UklGR")) {
+    return "webp";
+  }
+  if (base64.startsWith("Qk")) {
+    return "bmp";
+  }
+  if (base64.startsWith("PHN2Zy") || base64.startsWith("data:image/svg")) {
+    return "svg";
+  }
+  return "bin";
+};
+var sanitizeArtifactName = (name) => {
+  return name.replace(/[^a-zA-Z0-9]/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "").toLowerCase();
+};
+var createVirtualFilesystem = (artifacts) => {
+  const virtualFiles = /* @__PURE__ */ new Map();
+  const transformedArtifacts = artifacts.map((artifact) => {
+    const artifactName = sanitizeArtifactName(artifact.id);
+    return {
+      id: artifact.id,
+      type: artifact.type,
+      metadata: artifact.metadata,
+      tokens: artifact.tokens,
+      contents: artifact.contents.map((content, contentIndex) => {
+        const pageNumber = content.page;
+        return {
+          page: content.page,
+          text: content.text,
+          media: content.media?.map((media, mediaIndex) => {
+            if (media.base64 && media.base64.length > 0) {
+              const extension = detectImageFormat(media.base64);
+              let virtualPath;
+              if (pageNumber !== void 0) {
+                virtualPath = `/images/${artifactName}-page-${pageNumber}-image-${mediaIndex}.${extension}`;
+              } else {
+                virtualPath = `/images/${artifactName}-image-${mediaIndex}.${extension}`;
+              }
+              virtualFiles.set(virtualPath, media.base64);
+              return {
+                type: media.type,
+                url: media.url,
+                text: media.text,
+                x: media.x,
+                y: media.y,
+                width: media.width,
+                height: media.height,
+                imageType: media.imageType,
+                virtualPath,
+                originalBase64: `[BASE64: ${media.base64.length} chars]`
+                // For debugging
+              };
+            }
+            return {
+              type: media.type,
+              url: media.url,
+              text: media.text,
+              x: media.x,
+              y: media.y,
+              width: media.width,
+              height: media.height,
+              imageType: media.imageType
+            };
+          })
+        };
+      })
+    };
+  });
+  const totalImagesWithBase64 = Array.from(virtualFiles.keys()).length;
+  const manifest = {
+    count: artifacts.length,
+    artifacts: transformedArtifacts,
+    totalTokens: transformedArtifacts.reduce((sum, a) => sum + (a.tokens || 0), 0),
+    summary: {
+      textArtifacts: artifacts.filter((a) => a.type === "text").length,
+      imageArtifacts: artifacts.filter((a) => a.type === "image").length,
+      pdfArtifacts: artifacts.filter((a) => a.type === "pdf").length,
+      fileArtifacts: artifacts.filter((a) => a.type === "file").length
+    },
+    virtualFiles: {
+      count: totalImagesWithBase64,
+      paths: Array.from(virtualFiles.keys())
+    }
+  };
+  const getImageByPath = (path) => {
+    return virtualFiles.get(path);
+  };
+  const filesystem = {
+    "/artifact.json": JSON.stringify(transformedArtifacts, null, 2),
+    "/manifest.json": JSON.stringify(manifest, null, 2),
+    virtualFiles,
+    getImageByPath
+  };
+  return filesystem;
+};
+
+// src/strategies/agent/AgentTools.ts
+import "just-bash";
+import { Type } from "@sinclair/typebox";
+var BashParams = Type.Object({
+  command: Type.String({
+    description: "The bash command to execute"
+  }),
+  timeout: Type.Optional(
+    Type.Number({
+      description: "Timeout in milliseconds (default: 30000)"
+    })
+  )
+});
+var ReadParams = Type.Object({
+  file_path: Type.String({
+    description: "The absolute path to the file to read"
+  }),
+  offset: Type.Optional(
+    Type.Number({
+      description: "Line number to start reading from (1-indexed, default: 1)"
+    })
+  ),
+  limit: Type.Optional(
+    Type.Number({
+      description: "Maximum number of lines to read"
+    })
+  )
+});
+var GrepParams = Type.Object({
+  pattern: Type.String({
+    description: "The search pattern"
+  }),
+  path: Type.String({
+    description: "The file or directory to search in"
+  }),
+  options: Type.Optional(
+    Type.String({
+      description: "Additional grep options (e.g., '-r' for recursive, '-i' for case-insensitive)"
+    })
+  )
+});
+var FindParams = Type.Object({
+  path: Type.String({
+    description: "The directory to search in"
+  }),
+  name: Type.Optional(
+    Type.String({
+      description: "Filename pattern to match (e.g., '*.json')"
+    })
+  )
+});
+var LsParams = Type.Object({
+  path: Type.String({
+    description: "The directory to list"
+  }),
+  recursive: Type.Optional(
+    Type.Boolean({
+      description: "List recursively"
+    })
+  )
+});
+var SetOutputDataParams = Type.Object({
+  data: Type.Any({
+    description: "The output data to set. Can be any shape - will be validated against the schema."
+  })
+});
+var UpdateOutputDataParams = Type.Object({
+  changes: Type.Record(Type.String(), Type.Any(), {
+    description: "Changes to merge into the existing output data. Uses deep merge. Missing fields are preserved."
+  })
+});
+var ViewImageParams = Type.Object({
+  image_path: Type.String({
+    description: "The absolute path to the image file to view (e.g., '/artifacts/images/artifact-name-page-1-image-0.png')"
+  })
+});
+var FinishParams = Type.Object({});
+var FailParams = Type.Object({
+  reason: Type.String({
+    description: "Explanation of why extraction failed or what data could not be found."
+  })
+});
+var createVirtualFilesystemTools = (bash, getImageByPath) => {
+  const bashTool = {
+    name: "bash",
+    label: "Bash",
+    description: "Execute bash commands in the virtual filesystem. Use this to explore artifacts with commands like cat, grep, head, tail, jq, etc.",
+    parameters: BashParams,
+    execute: async (toolCallId, params, signal, onUpdate, ctx) => {
+      try {
+        const result = await bash.exec(params.command);
+        return {
+          content: [
+            {
+              type: "text",
+              text: result.exitCode === 0 ? result.stdout || "(no output)" : `Exit code ${result.exitCode}: ${result.stderr || result.stdout || "(no output)"}`
+            }
+          ],
+          details: {
+            exitCode: result.exitCode,
+            ...result.stderr && { stderr: result.stderr }
+          }
+        };
+      } catch (error) {
+        const errorMsg = error.message;
+        console.error(`[AgentTools] Bash command error: ${errorMsg}`);
+        console.error(`[AgentTools] Command: ${params.command}`);
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Error: ${errorMsg}`
+            }
+          ],
+          details: {
+            error: errorMsg
+          },
+          isError: true
+        };
+      }
+    }
+  };
+  const readTool = {
+    name: "read",
+    label: "Read File",
+    description: "Read the contents of a file from the virtual filesystem. Supports pagination with offset and limit parameters. Can read virtual image files (binary/base64 content).",
+    parameters: ReadParams,
+    execute: async (toolCallId, params, signal, onUpdate, ctx) => {
+      try {
+        if (getImageByPath && params.file_path.startsWith("/images/")) {
+          const imageData = getImageByPath(params.file_path);
+          if (imageData) {
+            const displayData = imageData.length > 1e3 ? imageData.slice(0, 1e3) + "... [truncated]" : imageData;
+            return {
+              content: [
+                {
+                  type: "text",
+                  text: `[IMAGE FILE: ${params.file_path}]
+Base64 content (${imageData.length} chars):
+${displayData}`
+                }
+              ],
+              details: {
+                path: params.file_path,
+                size: imageData.length,
+                truncated: imageData.length > 1e3
+              }
+            };
+          }
+        }
+        let command;
+        const offset = params.offset || 1;
+        const limit = params.limit;
+        const endLine = limit ? offset + limit - 1 : void 0;
+        if (limit && endLine) {
+          command = `sed -n '${offset},${endLine}p' "${params.file_path}"`;
+        } else if (offset > 1) {
+          command = `sed -n '${offset},$p' "${params.file_path}"`;
+        } else {
+          command = `cat "${params.file_path}"`;
+        }
+        const result = await bash.exec(command);
+        if (result.exitCode !== 0) {
+          return {
+            content: [
+              {
+                type: "text",
+                text: `Error reading file: ${result.stderr || "File not found"}`
+              }
+            ],
+            details: {
+              error: result.stderr || "File not found"
+            },
+            isError: true
+          };
+        }
+        return {
+          content: [
+            {
+              type: "text",
+              text: result.stdout
+            }
+          ],
+          details: {
+            lines: result.stdout.split("\n").length,
+            characters: result.stdout.length
+          }
+        };
+      } catch (error) {
+        const errorMsg = error.message;
+        console.error(`[AgentTools] Read error: ${errorMsg}`);
+        console.error(`[AgentTools] File path: ${params.file_path}`);
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Error: ${errorMsg}`
+            }
+          ],
+          details: {
+            error: errorMsg
+          },
+          isError: true
+        };
+      }
+    }
+  };
+  const grepTool = {
+    name: "grep",
+    label: "Grep",
+    description: "Search for patterns in files using grep",
+    parameters: GrepParams,
+    execute: async (toolCallId, params, signal, onUpdate, ctx) => {
+      try {
+        const options = params.options || "";
+        const command = `grep ${options} "${params.pattern}" "${params.path}" 2>/dev/null || echo "(no matches found)"`;
+        const result = await bash.exec(command);
+        return {
+          content: [
+            {
+              type: "text",
+              text: result.stdout || "(no matches found)"
+            }
+          ],
+          details: {
+            matches: result.stdout.split("\n").filter((line) => line.trim()).length
+          }
+        };
+      } catch (error) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `(no matches found)`
+            }
+          ],
+          details: {}
+        };
+      }
+    }
+  };
+  const findTool = {
+    name: "find",
+    label: "Find",
+    description: "Find files by name or pattern",
+    parameters: FindParams,
+    execute: async (toolCallId, params, signal, onUpdate, ctx) => {
+      try {
+        let command = `find "${params.path}" -type f`;
+        if (params.name) {
+          command = `find "${params.path}" -type f -name "${params.name}"`;
+        }
+        const result = await bash.exec(command);
+        return {
+          content: [
+            {
+              type: "text",
+              text: result.stdout || "(no files found)"
+            }
+          ],
+          details: {
+            files: result.stdout.split("\n").filter((line) => line.trim()).length
+          }
+        };
+      } catch (error) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Error: ${error.message}`
+            }
+          ],
+          details: {
+            error: error.message
+          },
+          isError: true
+        };
+      }
+    }
+  };
+  const lsTool = {
+    name: "ls",
+    label: "List Directory",
+    description: "List files and directories",
+    parameters: LsParams,
+    execute: async (toolCallId, params, signal, onUpdate, ctx) => {
+      try {
+        let command = `ls -la "${params.path}"`;
+        if (params.recursive) {
+          command = `ls -laR "${params.path}"`;
+        }
+        const result = await bash.exec(command);
+        if (result.exitCode !== 0) {
+          return {
+            content: [
+              {
+                type: "text",
+                text: `Error: ${result.stderr || "Directory not found"}`
+              }
+            ],
+            details: {
+              error: result.stderr || "Directory not found"
+            },
+            isError: true
+          };
+        }
+        return {
+          content: [
+            {
+              type: "text",
+              text: result.stdout
+            }
+          ],
+          details: {
+            entries: result.stdout.split("\n").filter((line) => line.trim() && !line.startsWith("total ")).length
+          }
+        };
+      } catch (error) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Error: ${error.message}`
+            }
+          ],
+          details: {
+            error: error.message
+          },
+          isError: true
+        };
+      }
+    }
+  };
+  const viewImageTool = {
+    name: "view_image",
+    label: "View Image",
+    description: "View an image file from the virtual filesystem. This injects the image as a visual message that the AI can see and analyze. Use this to examine images, screenshots, diagrams, or any visual content in the artifacts.",
+    parameters: ViewImageParams,
+    execute: async (toolCallId, params, signal, onUpdate, ctx) => {
+      try {
+        if (!getImageByPath) {
+          return {
+            content: [
+              {
+                type: "text",
+                text: "Error: Image viewing is not available"
+              }
+            ],
+            details: {
+              error: "Image viewing is not available"
+            },
+            isError: true
+          };
+        }
+        const imageData = getImageByPath(params.image_path);
+        if (!imageData) {
+          return {
+            content: [
+              {
+                type: "text",
+                text: `Error: Image not found at ${params.image_path}`
+              }
+            ],
+            details: {
+              error: `Image not found at ${params.image_path}`
+            },
+            isError: true
+          };
+        }
+        const getImageFormat = (path, data) => {
+          if (path.endsWith(".png")) return "image/png";
+          if (path.endsWith(".jpg") || path.endsWith(".jpeg")) return "image/jpeg";
+          if (path.endsWith(".gif")) return "image/gif";
+          if (path.endsWith(".webp")) return "image/webp";
+          if (path.endsWith(".bmp")) return "image/bmp";
+          if (path.endsWith(".svg")) return "image/svg+xml";
+          if (data.startsWith("/9j/")) return "image/jpeg";
+          if (data.startsWith("iVBORw0KGgo")) return "image/png";
+          if (data.startsWith("R0lGOD")) return "image/gif";
+          if (data.startsWith("Qk")) return "image/bmp";
+          if (data.startsWith("PHN2Zy")) return "image/svg+xml";
+          return "image/png";
+        };
+        const mimeType = getImageFormat(params.image_path, imageData);
+        return {
+          content: [
+            {
+              type: "text",
+              text: `[Viewing image: ${params.image_path}]`
+            },
+            {
+              type: "image",
+              data: imageData,
+              mimeType
+            }
+          ],
+          details: {
+            path: params.image_path,
+            format: mimeType,
+            size: imageData.length
+          }
+        };
+      } catch (error) {
+        const errorMsg = error.message;
+        console.error(`[AgentTools] View image error: ${errorMsg}`);
+        console.error(`[AgentTools] Image path: ${params.image_path}`);
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Error viewing image: ${errorMsg}`
+            }
+          ],
+          details: {
+            error: errorMsg
+          },
+          isError: true
+        };
+      }
+    }
+  };
+  return {
+    bash: bashTool,
+    read: readTool,
+    grep: grepTool,
+    find: findTool,
+    ls: lsTool,
+    view_image: viewImageTool
+  };
+};
+
+// src/strategies/agent/AgentStrategy.ts
+var defaultSystemPrompt = (schema, outputInstructions) => {
+  return `You are an autonomous data extraction agent. Your task is to explore the provided artifacts and extract structured data according to the given JSON schema.
+
+## Your Environment
+
+You have access to a virtual filesystem containing the artifacts to extract from:
+- "/artifact.json" - All artifacts in a structured JSON format (with embedded images replaced by virtual file paths)
+- "/manifest.json" - Summary and metadata about the artifacts
+- "/images/" - Virtual directory containing extracted image files (when artifacts have embedded images)
+
+## Virtual Image Files
+
+When artifacts contain embedded images (base64-encoded), they are extracted to separate files in "/images/" for easier access:
+- Image files are named: "/images/{artifact-name}-page-{n}-image-{i}.{ext}"
+  - {artifact-name}: Sanitized artifact ID (lowercase, special chars become dashes)
+  - page-{n}: Page number from the artifact (if available)
+  - image-{i}: Image index within that page
+  - {ext}: File extension determined from base64 (jpg, png, gif, webp, bmp, svg, or bin)
+- Examples: "/images/invoice-page-3-image-0.jpg" or "/images/report-image-1.png"
+- Use the "/images/" directory to access image data
+- The manifest shows which virtual files are available
+- Image format is shown in the file extension for easy identification
+
+## IMPORTANT: Do NOT Install Tools
+
+This is a **sandboxed environment** - you CANNOT install packages or tools:
+- \u274C DO NOT run: apt-get, pip install, npm install, brew install, etc.
+- \u274C DO NOT try to install tesseract, ocrmypdf, poppler, or any OCR tools
+- \u274C DO NOT check if tools exist with "which" or "command -v"
+- \u2705 ONLY use the provided tools listed below
+- \u2705 If a tool is missing, work with what you have or report it via fail()
+
+## Available Tools
+
+### Exploration Tools
+- **read** - Read file contents with pagination support (e.g., read {"file_path": "/manifest.json", "limit": 50})
+- **view_image** - View an image to see its contents visually (e.g., view_image {"image_path": "/images/doc-page-1-image-0.png"})
+- **bash** - Run shell commands (e.g., bash {"command": "head -20 /artifact.json"})
+- **grep** - Search for patterns in files
+- **find** - Find files by name or pattern
+- **ls** - List files and directories
+
+### Output Management Tools (IMPORTANT - Use These!)
+- **set_output_data** - Set the initial extraction output. Call this as soon as you find the first piece of data.
+  - Example: set_output_data({"data": {"company_name": "Acme Corp"}})
+  - The data can be any shape - you'll update it incrementally
+
+- **update_output_data** - Add or modify fields in the existing output data
+  - Example: update_output_data({"changes": {"address": "123 Main St"}})
+  - This merges new data with existing data (deep merge)
+  - Call this frequently as you discover more information
+
+- **finish** - Call this when extraction is complete and data validates against the schema
+  - Only works if the data is valid according to the schema
+  - This ends the extraction successfully
+
+- **fail** - Call this if the schema cannot be satisfied with available data
+  - Provide a reason explaining what data was missing or why extraction failed
+
+## CRITICAL: Incremental Data Updates
+
+**You MUST update the output data continuously as you explore!**
+
+1. **Start immediately**: As soon as you find the first field, call set_output_data
+2. **Update frequently**: Every time you find new information, call update_output_data
+3. **Build incrementally**: Don't wait until the end - keep adding data as you go
+4. **Use all tools**: Combine exploration tools with output tools
+
+### Example Workflow
+
+1. Read manifest: read {"file_path": "/manifest.json", "limit": 20}
+2. Find first data point: grep "company_name" /artifact.json
+3. **Set initial data**: set_output_data({"data": {"company_name": "Acme Inc"}})
+4. Continue exploring: read {"file_path": "/artifact.json", "offset": 50, "limit": 30}
+5. **Update with more data**: update_output_data({"changes": {"address": "123 Main St", "city": "Berlin"}})
+6. Check images: view_image {"image_path": "/images/doc-page-1-image-0.png"}
+7. **Update again**: update_output_data({"changes": {"has_logo": true}})
+8. Verify complete: Check all schema fields are present
+9. **Finish**: finish()
+
+## Efficient Exploration Strategy
+
+**Don't read entire files at once.** Files may be large. Instead:
+
+1. **Start small**: Read just the first 20-50 lines to understand the structure
+2. **Navigate selectively**: Use offset and limit to jump to relevant sections
+3. **Search first**: Use grep to find specific data before reading full content
+4. **Iterate**: Make multiple small reads rather than one giant read
+5. **Update as you go**: Call update_output_data immediately when you find data
+
+### Pagination Examples
+
+Read first 30 lines:
+read {"file_path": "/artifact.json", "limit": 30}
+
+Read lines 31-60 (page 2):
+read {"file_path": "/artifact.json", "offset": 31, "limit": 30}
+
+Read from line 100 to end:
+read {"file_path": "/artifact.json", "offset": 100}
+
+## Output Rules
+
+- **Update continuously**: Call update_output_data every time you find new information
+- **Start early**: Don't wait until the end - set initial data as soon as possible
+- **Use null for missing values**: If a field can't be found, set it to null
+- **Never guess**: Only extract information explicitly present in the artifacts
+- **Validate as you go**: The tools will tell you if your data has validation issues
+- **Finish properly**: You MUST call finish() to complete extraction successfully
+- **Fail if needed**: Use fail() if the schema truly cannot be satisfied
+
+${outputInstructions ? `
+## Additional Instructions
+
+${outputInstructions}
+` : ""}
+
+## JSON Schema
+
+${schema}
+
+## CRITICAL: Tool Calling Format
+
+When calling tools, you MUST provide the correct parameters:
+
+**CORRECT - read with file_path:**
+read {"file_path": "/manifest.json"}
+
+**CORRECT - read with pagination:**
+read {"file_path": "/artifact.json", "offset": 1, "limit": 50}
+
+**CORRECT - view image:**
+view_image {"image_path": "/images/doc-page-1-image-0.png"}
+
+**CORRECT - set output data:**
+set_output_data {"data": {"company_name": "Acme Corp"}}
+
+**CORRECT - update output:**
+update_output_data {"changes": {"address": "123 Main St"}}
+
+**CORRECT - finish:**
+finish {}
+
+**CORRECT - fail:**
+fail {"reason": "Document is not an invoice"}
+
+## Common Mistakes to AVOID
+
+\u274C WRONG: read {} (missing file_path)
+\u274C WRONG: read {file_path: "/path"} (missing quotes around property names)
+\u274C WRONG: read /path (not using JSON format)
+\u274C WRONG: set_output_data {company: "Name"} (missing quotes and data wrapper)
+\u274C WRONG: Trying to install tools with apt-get, pip, npm, etc. (not allowed in sandbox)
+
+## Remember
+
+1. **ALWAYS** use set_output_data or update_output_data when you find information
+2. **ALWAYS** call finish() when done (or fail() if impossible)
+3. **ALWAYS** provide required parameters when calling tools (file_path for read, data for set_output_data, etc.)
+4. **NEVER** try to install packages or external tools - work with what you have
+5. The output tools will validate your data and report issues
+6. You can update data multiple times - keep refining as you explore
+7. The CLI shows your progress in real-time as you update the output`;
+};
+var AgentStrategy = class {
+  name = "agent";
+  config;
+  constructor(config) {
+    this.config = config;
+  }
+  getEstimatedSteps() {
+    return this.config.maxSteps ?? 50;
+  }
+  async run(options) {
+    const debug = options.debug ?? this.config.debug;
+    const { telemetry } = options;
+    const maxSteps = this.config.maxSteps ?? 50;
+    const agentSpan = telemetry?.startSpan({
+      name: "strategy.agent",
+      kind: "AGENT",
+      attributes: {
+        "strategy.name": this.name,
+        "agent.max_steps": maxSteps,
+        "agent.model": this.config.model ? "custom" : `${this.config.provider}/${this.config.modelId}`,
+        "agent.artifacts.count": options.artifacts.length
+      }
+    });
+    const activeMessageSpans = /* @__PURE__ */ new Map();
+    const activeToolSpans = /* @__PURE__ */ new Map();
+    await options.events?.onStep?.({
+      step: 1,
+      total: this.getEstimatedSteps(),
+      label: "agent_explore"
+    });
+    debug?.step({
+      step: 1,
+      total: this.getEstimatedSteps(),
+      label: "agent_explore",
+      strategy: this.name
+    });
+    const filesystem = createVirtualFilesystem(options.artifacts);
+    const files = {
+      "/artifact.json": filesystem["/artifact.json"],
+      "/manifest.json": filesystem["/manifest.json"]
+    };
+    for (const [path, content] of filesystem.virtualFiles) {
+      files[path] = content;
+    }
+    const bash = new Bash2({
+      files,
+      cwd: "/"
+    });
+    const virtualTools = createVirtualFilesystemTools(bash, filesystem.getImageByPath);
+    const schema = JSON.stringify(options.schema, null, 2);
+    const systemPrompt = this.config.systemPrompt ?? defaultSystemPrompt(schema, this.config.outputInstructions);
+    const callId = `agent_${Date.now()}_${Math.random().toString(36).slice(2, 11)}`;
+    debug?.llmCallStart({
+      callId,
+      model: this.config.model ? JSON.stringify(this.config.model) : "default",
+      schemaName: "extract",
+      systemLength: systemPrompt.length,
+      userLength: 0,
+      artifactCount: options.artifacts.length
+    });
+    debug?.promptSystem({ callId, system: systemPrompt });
+    const startTime = Date.now();
+    const agentDir = this.config.agentDir;
+    const authStorage = agentDir ? AuthStorage.create(`${agentDir}/auth.json`) : AuthStorage.create();
+    if (this.config.apiKey && this.config.provider) {
+      authStorage.setRuntimeApiKey(this.config.provider, this.config.apiKey);
+    }
+    const modelRegistry = new ModelRegistry(authStorage);
+    let model = this.config.model;
+    if (!model && this.config.provider && this.config.modelId) {
+      if (this.config.verbose) {
+        console.error(`[AgentStrategy] Looking up model: ${this.config.provider}/${this.config.modelId}`);
+      }
+      model = modelRegistry.find(this.config.provider, this.config.modelId);
+      if (this.config.verbose) {
+        console.error(`[AgentStrategy] Model resolved: ${model ? "success" : "failed"}`);
+        if (model) {
+          console.error(`[AgentStrategy] Model info:`, JSON.stringify(model).slice(0, 200));
+        }
+      }
+    } else if (model && this.config.verbose) {
+      console.error(`[AgentStrategy] Using pre-configured model`);
+    }
+    const loader = new DefaultResourceLoader({
+      cwd: "/artifacts",
+      agentDir: agentDir || void 0,
+      systemPromptOverride: () => systemPrompt
+    });
+    await loader.reload();
+    const settingsManager = SettingsManager.inMemory({
+      compaction: { enabled: false }
+      // Disable compaction for extraction tasks
+    });
+    let currentOutput = null;
+    let isFinished = false;
+    let finishError = null;
+    let extractionFailed = false;
+    let failureReason = null;
+    const validateData = (data) => {
+      try {
+        JSON.stringify(data);
+        return { valid: true, errors: [] };
+      } catch (e) {
+        return { valid: false, errors: [e.message] };
+      }
+    };
+    const deepMerge = (target, source) => {
+      const output = Object.assign({}, target);
+      if (isObject(target) && isObject(source)) {
+        Object.keys(source).forEach((key) => {
+          if (isObject(source[key])) {
+            if (!(key in target)) {
+              Object.assign(output, { [key]: source[key] });
+            } else {
+              output[key] = deepMerge(target[key], source[key]);
+            }
+          } else {
+            Object.assign(output, { [key]: source[key] });
+          }
+        });
+      }
+      return output;
+    };
+    const isObject = (item) => {
+      return item && typeof item === "object" && !Array.isArray(item);
+    };
+    await options.events?.onStep?.({
+      step: 2,
+      total: this.getEstimatedSteps(),
+      label: "agent_init"
+    });
+    debug?.step({
+      step: 2,
+      total: this.getEstimatedSteps(),
+      label: "agent_init",
+      strategy: this.name
+    });
+    const { Type: Type2 } = await import("@sinclair/typebox");
+    const setOutputDataTool = {
+      name: "set_output_data",
+      label: "Set Output Data",
+      description: "Set the initial output data. You can use any structure - it will be validated against the schema.",
+      parameters: Type2.Object({
+        data: Type2.Any({ description: "The output data to set" })
+      }),
+      execute: async (toolCallId, params) => {
+        currentOutput = params.data;
+        const validation = validateData(params.data);
+        const status = validation.valid ? "\u2713 Valid structure" : `\u2717 Validation issues: ${validation.errors.join(", ")}`;
+        await options.events?.onStep?.({
+          step: stepCount + 1,
+          total: this.getEstimatedSteps(),
+          label: `Output: ${JSON.stringify(params.data).slice(0, 50)}...`
+        });
+        return {
+          content: [{ type: "text", text: `Output data set. ${status}` }],
+          details: { validation }
+        };
+      }
+    };
+    const updateOutputDataTool = {
+      name: "update_output_data",
+      label: "Update Output Data",
+      description: "Update the output data by merging changes. Existing fields are preserved, new fields are added.",
+      parameters: Type2.Object({
+        changes: Type2.Record(Type2.String(), Type2.Any(), {
+          description: "Changes to merge into existing data"
+        })
+      }),
+      execute: async (toolCallId, params) => {
+        if (currentOutput === null) {
+          return {
+            content: [{ type: "text", text: "Error: No output data set yet. Use set_output_data first." }],
+            isError: true
+          };
+        }
+        currentOutput = deepMerge(currentOutput, params.changes);
+        const validation = validateData(currentOutput);
+        const status = validation.valid ? "\u2713 Valid structure" : `\u2717 Validation issues: ${validation.errors.join(", ")}`;
+        await options.events?.onStep?.({
+          step: stepCount + 1,
+          total: this.getEstimatedSteps(),
+          label: `Updated: ${JSON.stringify(params.changes).slice(0, 50)}...`
+        });
+        return {
+          content: [{ type: "text", text: `Output data updated. ${status}` }],
+          details: { validation, currentOutput }
+        };
+      }
+    };
+    const finishTool = {
+      name: "finish",
+      label: "Finish Extraction",
+      description: "Complete the extraction. Can only be called when data validates against the schema.",
+      parameters: Type2.Object({}),
+      execute: async (toolCallId) => {
+        if (extractionFailed) {
+          return {
+            content: [{ type: "text", text: "Cannot finish - extraction was marked as failed." }],
+            isError: true
+          };
+        }
+        if (currentOutput === null) {
+          return {
+            content: [{ type: "text", text: "Error: No output data set. Extract data first." }],
+            isError: true
+          };
+        }
+        const validation = validateData(currentOutput);
+        if (!validation.valid) {
+          finishError = `Schema validation failed: ${validation.errors.join(", ")}`;
+          return {
+            content: [{
+              type: "text",
+              text: `Cannot finish: ${finishError}
+
+Fix the data and try again, or use fail() if extraction is impossible.`
+            }],
+            isError: true
+          };
+        }
+        isFinished = true;
+        return {
+          content: [{ type: "text", text: "\u2713 Extraction complete! Data validated successfully." }]
+        };
+      }
+    };
+    const failTool = {
+      name: "fail",
+      label: "Fail Extraction",
+      description: "Mark extraction as failed when the schema cannot be satisfied with the available data.",
+      parameters: Type2.Object({
+        reason: Type2.String({ description: "Why extraction failed or what data was missing" })
+      }),
+      execute: async (toolCallId, params) => {
+        extractionFailed = true;
+        failureReason = params.reason;
+        return {
+          content: [{ type: "text", text: `Extraction marked as failed: ${params.reason}` }]
+        };
+      }
+    };
+    const allTools = [
+      virtualTools.read,
+      virtualTools.bash,
+      virtualTools.grep,
+      virtualTools.find,
+      virtualTools.ls,
+      setOutputDataTool,
+      updateOutputDataTool,
+      finishTool,
+      failTool
+    ];
+    if (this.config.verbose) {
+      console.error(`[AgentStrategy] Creating session with ${allTools.length} tools`);
+      console.error(`[AgentStrategy] Tool names: ${allTools.map((t) => t.name).join(", ")}`);
+      allTools.forEach((tool) => {
+        console.error(`[AgentStrategy] Tool "${tool.name}" details:`);
+        console.error(`  - label: ${tool.label}`);
+        console.error(`  - description: ${tool.description?.slice(0, 100)}...`);
+        console.error(`  - has parameters: ${!!tool.parameters}`);
+        if (tool.parameters) {
+          console.error(`  - parameters type: ${tool.parameters.type}`);
+          console.error(`  - required fields: ${JSON.stringify(tool.parameters.required)}`);
+        }
+      });
+    }
+    const { session } = await createAgentSession({
+      model,
+      authStorage,
+      modelRegistry,
+      resourceLoader: loader,
+      sessionManager: SessionManager.inMemory(),
+      settingsManager,
+      tools: [],
+      // No default tools
+      customTools: allTools
+    });
+    if (this.config.verbose) {
+      console.error(`[AgentStrategy] Session created successfully`);
+    }
+    await options.events?.onStep?.({
+      step: 3,
+      total: this.getEstimatedSteps(),
+      label: "agent_session_ready"
+    });
+    debug?.step({
+      step: 3,
+      total: this.getEstimatedSteps(),
+      label: "agent_session_ready",
+      strategy: this.name
+    });
+    let usage = { inputTokens: 0, outputTokens: 0, totalTokens: 0 };
+    let stepCount = 0;
+    let finalResponse = "";
+    const maxToolCalls = maxSteps;
+    let textBuffer = "";
+    try {
+      const unsubscribe = session.subscribe((event) => {
+        try {
+          switch (event.type) {
+            case "message_update": {
+              if (event.assistantMessageEvent.type === "text_delta") {
+                const delta = event.assistantMessageEvent.delta;
+                finalResponse += delta;
+                options.events?.onAgentMessage?.({
+                  content: delta,
+                  role: "assistant"
+                });
+                textBuffer += delta;
+                let newlineIndex;
+                while ((newlineIndex = textBuffer.indexOf("\n")) !== -1) {
+                  const line = textBuffer.slice(0, newlineIndex).trim();
+                  textBuffer = textBuffer.slice(newlineIndex + 1);
+                  if (line.length > 0) {
+                    options.events?.onStep?.({
+                      step: stepCount,
+                      total: this.getEstimatedSteps(),
+                      label: `\u2192 ${line.slice(0, 120)}`
+                    });
+                  }
+                }
+                if (textBuffer.length > 100) {
+                  const line = textBuffer.trim();
+                  if (line.length > 0) {
+                    options.events?.onStep?.({
+                      step: stepCount,
+                      total: this.getEstimatedSteps(),
+                      label: `\u2192 ${line.slice(0, 120)}`
+                    });
+                  }
+                  textBuffer = "";
+                }
+              }
+              break;
+            }
+            case "tool_execution_start": {
+              stepCount++;
+              if (telemetry && agentSpan) {
+                const toolSpan = telemetry.startSpan({
+                  name: `agent.tool.${event.toolName}`,
+                  kind: "TOOL",
+                  parentSpan: agentSpan,
+                  attributes: {
+                    "tool.name": event.toolName,
+                    "tool.call_id": event.toolCallId,
+                    "tool.args": JSON.stringify(event.args || {})
+                  }
+                });
+                activeToolSpans.set(event.toolCallId, toolSpan);
+              }
+              let label;
+              let detail;
+              const args = event.args;
+              const toolName = event.toolName;
+              const toolStartEvent = {
+                toolName,
+                toolCallId: event.toolCallId,
+                args: args || {}
+              };
+              options.events?.onAgentToolStart?.(toolStartEvent);
+              if (toolName === "read" && args?.file_path) {
+                const fileName = args.file_path.split("/").pop() || args.file_path;
+                const pagination = [];
+                if (args.offset && args.offset > 1) {
+                  pagination.push(`offset ${args.offset}`);
+                }
+                if (args.limit) {
+                  pagination.push(`limit ${args.limit}`);
+                }
+                const paginationStr = pagination.length > 0 ? ` (${pagination.join(", ")})` : "";
+                label = `Read ${fileName}${paginationStr}`;
+                detail = "";
+              } else if (toolName === "bash" && args?.command) {
+                const cmd = args.command.length > 40 ? args.command.slice(0, 37) + "..." : args.command;
+                label = `Bash: ${cmd}`;
+                detail = "";
+              } else if (toolName === "grep" && args?.pattern) {
+                label = `Grep "${args.pattern}"`;
+                detail = args.path ? `in ${args.path.split("/").pop()}` : "";
+              } else if (toolName === "find" && args?.path) {
+                label = `Find`;
+                detail = args.name ? `"${args.name}" in ${args.path}` : `in ${args.path}`;
+              } else if (toolName === "ls" && args?.path) {
+                label = `List ${args.path}`;
+                detail = args.recursive ? "recursive" : "";
+              } else if (toolName === "set_output_data") {
+                label = "Set Output";
+                detail = args?.data ? JSON.stringify(args.data).slice(0, 80) : "";
+              } else if (toolName === "update_output_data") {
+                label = "Update Output";
+                detail = args?.changes ? JSON.stringify(args.changes).slice(0, 80) : "";
+              } else if (toolName === "finish") {
+                label = "Finish";
+                detail = "";
+              } else if (toolName === "fail") {
+                label = "Fail";
+                detail = args?.reason || "";
+              } else {
+                label = toolName;
+                detail = args ? JSON.stringify(args).slice(0, 100) : "";
+              }
+              options.events?.onStep?.({
+                step: stepCount + 1,
+                total: this.getEstimatedSteps(),
+                label,
+                detail
+              });
+              debug?.step({
+                step: stepCount + 1,
+                total: this.getEstimatedSteps(),
+                label,
+                strategy: this.name
+              });
+              break;
+            }
+            case "tool_execution_end": {
+              const toolEndEvent = event;
+              const toolSpan = activeToolSpans.get(toolEndEvent.toolCallId);
+              if (toolSpan && telemetry) {
+                const hasError = toolEndEvent.isError || toolEndEvent.error;
+                telemetry.endSpan(toolSpan, {
+                  status: hasError ? "error" : "ok",
+                  error: hasError ? new Error(toolEndEvent.error || "Tool execution failed") : void 0,
+                  output: toolEndEvent.result
+                });
+                activeToolSpans.delete(toolEndEvent.toolCallId);
+              }
+              options.events?.onAgentToolEnd?.({
+                toolCallId: toolEndEvent.toolCallId,
+                result: toolEndEvent.result,
+                error: toolEndEvent.error || toolEndEvent.isError ? toolEndEvent.error || "Tool execution failed" : void 0
+              });
+              if (toolEndEvent.isError || toolEndEvent.error) {
+                const errorMsg = toolEndEvent.error || "Unknown tool error";
+                const toolName = toolEndEvent.toolName || "unknown";
+                const toolCallId = toolEndEvent.toolCallId || "unknown";
+                if (this.config.verbose) {
+                  console.error(`[AgentStrategy] Tool execution failed: ${errorMsg}`);
+                  console.error(`[AgentStrategy] Tool: ${toolName}, Call ID: ${toolCallId}`);
+                  if (toolEndEvent.result) {
+                    console.error(`[AgentStrategy] Result:`, JSON.stringify(toolEndEvent.result));
+                  }
+                }
+              }
+              break;
+            }
+            case "agent_end": {
+              if (textBuffer.trim().length > 0) {
+                options.events?.onStep?.({
+                  step: stepCount,
+                  total: this.getEstimatedSteps(),
+                  label: `\u2192 ${textBuffer.trim().slice(0, 120)}`
+                });
+                textBuffer = "";
+              }
+              if (event.messages && event.messages.length > 0) {
+                const inputTokens = event.messages.reduce((sum, msg) => {
+                  if (msg.role === "user") {
+                    return sum + Math.ceil(JSON.stringify(msg.content).length / 4);
+                  }
+                  return sum;
+                }, 0);
+                const outputTokens = event.messages.reduce((sum, msg) => {
+                  if (msg.role === "assistant") {
+                    return sum + Math.ceil(JSON.stringify(msg.content).length / 4);
+                  }
+                  return sum;
+                }, 0);
+                usage = {
+                  inputTokens,
+                  outputTokens,
+                  totalTokens: inputTokens + outputTokens
+                };
+              }
+              options.events?.onStep?.({
+                step: stepCount + 1,
+                total: this.getEstimatedSteps(),
+                label: "agent_complete"
+              });
+              debug?.step({
+                step: stepCount + 1,
+                total: this.getEstimatedSteps(),
+                label: "agent_complete",
+                strategy: this.name
+              });
+              break;
+            }
+            case "message_start": {
+              const messageKey = `msg_${Date.now()}_${Math.random().toString(36).slice(2, 11)}`;
+              if (telemetry && agentSpan) {
+                const llmSpan = telemetry.startSpan({
+                  name: "agent.llm.generate",
+                  kind: "LLM",
+                  parentSpan: agentSpan,
+                  attributes: {
+                    "llm.message_type": event.message?.role || "unknown",
+                    "llm.type": "agent_message"
+                  }
+                });
+                activeMessageSpans.set(messageKey, llmSpan);
+                event._telemetryKey = messageKey;
+              }
+              break;
+            }
+            case "message_end": {
+              const messageKey = event._telemetryKey;
+              if (messageKey) {
+                const llmSpan = activeMessageSpans.get(messageKey);
+                if (llmSpan && telemetry) {
+                  telemetry.endSpan(llmSpan, {
+                    status: "ok",
+                    output: finalResponse.slice(-200)
+                    // Last 200 chars as output preview
+                  });
+                  activeMessageSpans.delete(messageKey);
+                }
+              }
+              break;
+            }
+            case "agent_start": {
+              if (this.config.verbose) {
+                console.error("[AgentStrategy] Agent started processing");
+              }
+              break;
+            }
+            case "turn_start":
+            case "turn_end": {
+              break;
+            }
+            case "auto_compaction_start":
+            case "auto_compaction_end":
+            case "auto_retry_start":
+            case "auto_retry_end": {
+              break;
+            }
+            default: {
+              const unhandledEvent = event;
+              if (unhandledEvent.type && !unhandledEvent.type.includes("_")) {
+                if (this.config.verbose) {
+                  console.error(`[AgentStrategy] Unexpected event type: ${unhandledEvent.type}`);
+                }
+              }
+              break;
+            }
+          }
+        } catch (eventHandlerError) {
+          if (this.config.verbose) {
+            console.error(`[AgentStrategy] Error in event handler: ${eventHandlerError.message}`);
+            console.error("AgentStrategy event handler error:", eventHandlerError);
+          }
+          throw eventHandlerError;
+        }
+      });
+      await session.prompt(
+        "Begin exploring the artifacts and extract the required data according to the schema. Start by reading the manifest file.",
+        {
+          // Ensure the agent keeps running until it calls finish() or fail()
+        }
+      );
+      if (currentOutput === null && !extractionFailed && !isFinished) {
+        if (this.config.verbose) {
+          console.error("[AgentStrategy] No output after first run. Sending retry prompt...");
+        }
+        await options.events?.onStep?.({
+          step: stepCount + 1,
+          total: this.getEstimatedSteps(),
+          label: "Retry: forcing output extraction"
+        });
+        const retryUnsubscribe = session.subscribe((event) => {
+          try {
+            switch (event.type) {
+              case "message_update": {
+                if (event.assistantMessageEvent.type === "text_delta") {
+                  const delta = event.assistantMessageEvent.delta;
+                  finalResponse += delta;
+                  options.events?.onAgentMessage?.({
+                    content: delta,
+                    role: "assistant"
+                  });
+                  textBuffer += delta;
+                  let newlineIndex;
+                  while ((newlineIndex = textBuffer.indexOf("\n")) !== -1) {
+                    const line = textBuffer.slice(0, newlineIndex).trim();
+                    textBuffer = textBuffer.slice(newlineIndex + 1);
+                    if (line.length > 0) {
+                      options.events?.onStep?.({
+                        step: stepCount,
+                        total: this.getEstimatedSteps(),
+                        label: `\u2192 ${line.slice(0, 120)}`
+                      });
+                    }
+                  }
+                  if (textBuffer.length > 100) {
+                    const line = textBuffer.trim();
+                    if (line.length > 0) {
+                      options.events?.onStep?.({
+                        step: stepCount,
+                        total: this.getEstimatedSteps(),
+                        label: `\u2192 ${line.slice(0, 120)}`
+                      });
+                    }
+                    textBuffer = "";
+                  }
+                }
+                break;
+              }
+              case "tool_execution_start": {
+                stepCount++;
+                const toolName = event.toolName;
+                const args = event.args;
+                let label = toolName;
+                if (toolName === "set_output_data") {
+                  label = "Set Output (retry)";
+                } else if (toolName === "update_output_data") {
+                  label = "Update Output (retry)";
+                } else if (toolName === "finish") {
+                  label = "Finish (retry)";
+                } else if (toolName === "fail") {
+                  label = "Fail (retry)";
+                }
+                options.events?.onStep?.({
+                  step: stepCount + 1,
+                  total: this.getEstimatedSteps(),
+                  label
+                });
+                break;
+              }
+            }
+          } catch (eventHandlerError) {
+            if (this.config.verbose) {
+              console.error(`[AgentStrategy] Error in retry event handler: ${eventHandlerError.message}`);
+            }
+          }
+        });
+        await session.prompt(
+          `You have explored the artifacts but haven't called any output tools yet. You MUST now extract data and call either:
+1. set_output_data with the extracted data, then finish()
+2. fail() if the document doesn't contain the required information
+
+The schema requires: ${JSON.stringify(options.schema).slice(0, 200)}...
+
+Extract what you can from the artifacts and set the output data NOW.`,
+          {}
+        );
+        retryUnsubscribe();
+      }
+      unsubscribe();
+      const durationMs = Date.now() - startTime;
+      let extractedData;
+      if (extractionFailed) {
+        throw new Error(`Extraction failed: ${failureReason}`);
+      }
+      if (!isFinished) {
+        if (currentOutput !== null) {
+          if (this.config.verbose) {
+            console.error("[AgentStrategy] Warning: Agent did not call finish(). Using collected data.");
+          }
+          const validation = validateData(currentOutput);
+          if (!validation.valid && this.config.verbose) {
+            console.error(`[AgentStrategy] Data validation issues: ${validation.errors.join(", ")}`);
+          }
+          extractedData = currentOutput;
+        } else {
+          const toolCallsMade = stepCount > 0;
+          const toolsFailed = toolCallsMade && currentOutput === null;
+          if (toolsFailed) {
+            const errorMsg = `Agent did not produce any output data. The model may not support tool calling properly.
+
+Troubleshooting:
+1. Check if your model supports function calling/tool use
+2. Try a different model like anthropic/claude-sonnet-4 or openai/gpt-4o
+3. See MODEL_COMPATIBILITY.md for supported models
+
+If you continue to see "Tool execution failed" errors with empty tool names,
+the model is not compatible with the agent strategy. Use --strategy simple instead.`;
+            throw new Error(errorMsg);
+          } else {
+            const errorMsg = `Agent did not produce any output data. No data was extracted.
+
+This can happen when:
+- The model doesn't support tool calling properly
+- The agent got confused and didn't use the output tools
+- The document doesn't contain extractable data
+
+Suggestions:
+1. Try a different model with better tool support (anthropic/claude-sonnet-4)
+2. Use --strategy simple for models without tool calling
+3. Check if the document actually contains the data specified in your schema
+
+Retry was attempted but the agent still didn't produce output.`;
+            throw new Error(errorMsg);
+          }
+        }
+      } else {
+        if (currentOutput === null) {
+          throw new Error("Agent called finish() but no output data was set.");
+        }
+        extractedData = currentOutput;
+      }
+      debug?.rawResponse({ callId, response: extractedData });
+      debug?.llmCallComplete({
+        callId,
+        success: true,
+        inputTokens: usage.inputTokens,
+        outputTokens: usage.outputTokens,
+        totalTokens: usage.totalTokens,
+        durationMs
+      });
+      await options.events?.onStep?.({
+        step: this.getEstimatedSteps(),
+        total: this.getEstimatedSteps(),
+        label: "extract"
+      });
+      debug?.step({
+        step: this.getEstimatedSteps(),
+        total: this.getEstimatedSteps(),
+        label: "extract",
+        strategy: this.name
+      });
+      if (telemetry) {
+        for (const [key, span] of activeMessageSpans.entries()) {
+          telemetry.endSpan(span, { status: "ok" });
+        }
+        activeMessageSpans.clear();
+        for (const [key, span] of activeToolSpans.entries()) {
+          telemetry.endSpan(span, { status: "ok" });
+        }
+        activeToolSpans.clear();
+        if (agentSpan) {
+          telemetry.endSpan(agentSpan, {
+            status: "ok",
+            output: extractedData
+          });
+        }
+      }
+      return { data: extractedData, usage };
+    } catch (error) {
+      const durationMs = Date.now() - startTime;
+      debug?.llmCallComplete({
+        callId,
+        success: false,
+        inputTokens: usage.inputTokens,
+        outputTokens: usage.outputTokens,
+        totalTokens: usage.totalTokens,
+        durationMs,
+        error: error.message
+      });
+      if (telemetry) {
+        for (const [key, span] of activeMessageSpans.entries()) {
+          telemetry.endSpan(span, {
+            status: "error",
+            error: error instanceof Error ? error : new Error(String(error))
+          });
+        }
+        activeMessageSpans.clear();
+        for (const [key, span] of activeToolSpans.entries()) {
+          telemetry.endSpan(span, {
+            status: "error",
+            error: error instanceof Error ? error : new Error(String(error))
+          });
+        }
+        activeToolSpans.clear();
+        if (agentSpan) {
+          telemetry.endSpan(agentSpan, {
+            status: "error",
+            error: error instanceof Error ? error : new Error(String(error))
+          });
+        }
+      }
+      throw error;
+    } finally {
+      session.dispose();
+    }
+  }
+};
+var agent = (config) => {
+  return new AgentStrategy(config);
+};
+export {
+  AgentStrategy,
+  DoublePassAutoMergeStrategy,
+  DoublePassStrategy,
+  ParallelAutoMergeStrategy,
+  ParallelStrategy,
+  SequentialAutoMergeStrategy,
+  SequentialStrategy,
+  SimpleStrategy,
+  agent,
+  doublePass,
+  doublePassAutoMerge,
+  parallel,
+  parallelAutoMerge,
+  sequential,
+  sequentialAutoMerge,
+  simple
+};
+//# sourceMappingURL=strategies.js.map