@struktur/sdk 2.2.0 → 2.3.1

package/dist/strategies.js

@@ -2416,7 +2416,1501 @@ var DoublePassAutoMergeStrategy = class {
 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,
@@ -2424,6 +3918,7 @@ export {
   SequentialAutoMergeStrategy,
   SequentialStrategy,
   SimpleStrategy,
+  agent,
   doublePass,
   doublePassAutoMerge,
   parallel,