@doclo/core 0.1.5

package/dist/index.js

@@ -0,0 +1,2293 @@
+// src/internal/validation-utils.ts
+function aggregateMetrics(metrics) {
+  const byProvider = {};
+  const result = metrics.reduce((acc, m) => {
+    acc.totalDurationMs += m.ms;
+    acc.totalCostUSD += m.costUSD || 0;
+    acc.totalInputTokens += m.inputTokens || 0;
+    acc.totalOutputTokens += m.outputTokens || 0;
+    acc.totalCacheCreationTokens += m.cacheCreationInputTokens || 0;
+    acc.totalCacheReadTokens += m.cacheReadInputTokens || 0;
+    if (m.provider) {
+      if (!byProvider[m.provider]) {
+        byProvider[m.provider] = { costUSD: 0, inputTokens: 0, outputTokens: 0, callCount: 0 };
+      }
+      byProvider[m.provider].costUSD += m.costUSD || 0;
+      byProvider[m.provider].inputTokens += m.inputTokens || 0;
+      byProvider[m.provider].outputTokens += m.outputTokens || 0;
+      byProvider[m.provider].callCount += 1;
+    }
+    return acc;
+  }, {
+    totalDurationMs: 0,
+    totalCostUSD: 0,
+    totalInputTokens: 0,
+    totalOutputTokens: 0,
+    totalCacheCreationTokens: 0,
+    totalCacheReadTokens: 0,
+    stepCount: metrics.length,
+    byProvider
+  });
+  return result;
+}
+var node = (key, run) => ({ key, run });
+async function runPipeline(steps, input, observabilityContext) {
+  const artifacts = {};
+  const metrics = [];
+  const ctx = {
+    stepId: observabilityContext?.stepId,
+    artifacts,
+    emit: (k, v) => {
+      artifacts[k] = v;
+    },
+    metrics: { push: (m) => metrics.push(m) },
+    observability: observabilityContext
+  };
+  let acc = input;
+  for (const s of steps) {
+    acc = await s.run(acc, ctx);
+    ctx.emit(s.key, acc);
+  }
+  return { output: acc, artifacts, metrics };
+}
+var FlowExecutionError = class _FlowExecutionError extends Error {
+  constructor(message, failedStep, failedStepIndex, failedStepType, completedSteps, originalError, partialArtifacts) {
+    super(message);
+    this.failedStep = failedStep;
+    this.failedStepIndex = failedStepIndex;
+    this.failedStepType = failedStepType;
+    this.completedSteps = completedSteps;
+    this.originalError = originalError;
+    this.partialArtifacts = partialArtifacts;
+    this.name = "FlowExecutionError";
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, _FlowExecutionError);
+    }
+  }
+};
+var FlowValidationError = class _FlowValidationError extends Error {
+  constructor(message, reason, suggestions, sourceNode, targetNode, sourceOutputType, targetInputTypes) {
+    super(message);
+    this.reason = reason;
+    this.suggestions = suggestions;
+    this.sourceNode = sourceNode;
+    this.targetNode = targetNode;
+    this.sourceOutputType = sourceOutputType;
+    this.targetInputTypes = targetInputTypes;
+    this.name = "FlowValidationError";
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, _FlowValidationError);
+    }
+  }
+};
+var NODE_COMPATIBILITY_MATRIX = {
+  parse: {
+    parse: {
+      valid: false,
+      reason: "Cannot chain parse nodes. Parse is typically the starting node."
+    },
+    split: {
+      valid: false,
+      reason: "Split requires FlowInput, but parse outputs DocumentIR. Use split directly on input instead.",
+      note: "If you need to re-split after parsing, use trigger to invoke a child flow with FlowInput."
+    },
+    categorize: {
+      valid: true,
+      note: "categorize accepts DocumentIR and wraps it with {input, category}"
+    },
+    extract: {
+      valid: true,
+      note: "extract accepts DocumentIR and produces typed JSON"
+    },
+    chunk: {
+      valid: true,
+      note: "chunk accepts DocumentIR and produces ChunkOutput for RAG"
+    },
+    combine: {
+      valid: false,
+      reason: "Parse outputs DocumentIR (single document), not an array. Combine requires array input from forEach.",
+      note: "Use parse with chunked:true to output DocumentIR[], then use combine."
+    },
+    trigger: {
+      valid: true,
+      note: "trigger accepts any input type"
+    },
+    output: {
+      valid: true,
+      note: "output node can follow any node to select or transform results"
+    }
+  },
+  split: {
+    parse: {
+      valid: true,
+      requiresForEach: true,
+      reason: "Split outputs SplitDocument[] which requires forEach. forEach auto-unwraps SplitDocument.input \u2192 FlowInput for parse.",
+      note: "Enable forEach on split node before connecting to parse."
+    },
+    split: {
+      valid: false,
+      reason: "Cannot nest split operations. Split nodes cannot appear in forEach itemFlow."
+    },
+    categorize: {
+      valid: true,
+      requiresForEach: true,
+      reason: "Split outputs SplitDocument[] which requires forEach. forEach auto-unwraps SplitDocument.input for categorize."
+    },
+    extract: {
+      valid: true,
+      requiresForEach: true,
+      reason: "Split outputs SplitDocument[] which requires forEach. forEach auto-unwraps SplitDocument.input for extract."
+    },
+    chunk: {
+      valid: false,
+      reason: "SplitDocument output is incompatible with Chunk input. Chunk expects DocumentIR or DocumentIR[].",
+      note: "Use parse in forEach after split to convert SplitDocument \u2192 DocumentIR, then chunk."
+    },
+    combine: {
+      valid: false,
+      reason: "Combine should appear AFTER forEach completes, not as a forEach itemFlow step.",
+      note: "Place combine after the forEach block to merge results."
+    },
+    trigger: {
+      valid: true,
+      requiresForEach: true,
+      reason: "Split outputs SplitDocument[] which requires forEach for processing.",
+      note: "forEach auto-unwraps SplitDocument.input for child flow."
+    },
+    output: {
+      valid: true,
+      note: "output node can follow any node to select or transform results"
+    }
+  },
+  categorize: {
+    parse: {
+      valid: true,
+      note: "categorize outputs {input, category}. Conditional can unwrap this or use directly."
+    },
+    split: {
+      valid: false,
+      reason: "Split requires FlowInput, but categorize outputs {input, category}.",
+      note: "Use conditional to unwrap and pass input field to split."
+    },
+    categorize: {
+      valid: true,
+      note: "Can chain categorize nodes for multi-level classification."
+    },
+    extract: {
+      valid: true,
+      note: "extract can process the categorized document."
+    },
+    chunk: {
+      valid: false,
+      reason: "Categorize wraps input as {input, category}. Chunk needs unwrapped DocumentIR.",
+      note: "Use conditional to unwrap input field before chunk."
+    },
+    combine: {
+      valid: false,
+      reason: "Categorize outputs single result {input, category}, not an array. Combine requires array input."
+    },
+    trigger: {
+      valid: true,
+      note: "trigger accepts any input type, including {input, category}"
+    },
+    output: {
+      valid: true,
+      note: "output node can follow any node to select or transform results"
+    }
+  },
+  extract: {
+    parse: {
+      valid: false,
+      reason: "Extract outputs typed JSON (terminal node). Cannot pipe JSON to parse.",
+      note: "Extract should be one of the last steps in a flow. Use combine if extracting in parallel."
+    },
+    split: {
+      valid: false,
+      reason: "Extract outputs typed JSON (terminal node). Cannot pipe JSON to split."
+    },
+    categorize: {
+      valid: false,
+      reason: "Extract outputs typed JSON (terminal node). Cannot pipe JSON to categorize."
+    },
+    extract: {
+      valid: false,
+      reason: "Extract outputs typed JSON (terminal node). Cannot chain extractions on JSON output.",
+      note: "If you need multi-step extraction, extract from DocumentIR/ChunkOutput in parallel, then combine."
+    },
+    chunk: {
+      valid: false,
+      reason: "Extract outputs typed JSON, not DocumentIR. Chunk expects DocumentIR input."
+    },
+    combine: {
+      valid: true,
+      note: "Use combine to merge parallel extraction results from forEach."
+    },
+    trigger: {
+      valid: true,
+      note: "trigger accepts any input type, including extracted JSON"
+    },
+    output: {
+      valid: true,
+      note: "output node can follow any node to select or transform results"
+    }
+  },
+  chunk: {
+    parse: {
+      valid: false,
+      reason: "Chunk outputs ChunkOutput (specialized type), not FlowInput. Parse expects FlowInput as input."
+    },
+    split: {
+      valid: false,
+      reason: "Chunk outputs ChunkOutput, incompatible with Split input (FlowInput)."
+    },
+    categorize: {
+      valid: false,
+      reason: "Chunk outputs ChunkOutput, incompatible with Categorize input (DocumentIR|FlowInput).",
+      note: "Categorize before chunking, not after."
+    },
+    extract: {
+      valid: true,
+      note: "extract has special handling for ChunkOutput - extracts data from chunks."
+    },
+    chunk: {
+      valid: false,
+      reason: "Cannot chain chunk operations. Chunk only once per document.",
+      note: "Different chunking strategies should be applied to the original DocumentIR, not to chunks."
+    },
+    combine: {
+      valid: false,
+      reason: "Chunk outputs ChunkOutput (specialized type), not an array type. Combine expects T[].",
+      note: "Use chunk on individual documents in forEach, then extract, then combine extractions."
+    },
+    trigger: {
+      valid: true,
+      note: "trigger accepts any input type, including ChunkOutput"
+    },
+    output: {
+      valid: true,
+      note: "output node can follow any node to select or transform results"
+    }
+  },
+  combine: {
+    parse: {
+      valid: true,
+      note: "After combining, result can be re-parsed if needed."
+    },
+    split: {
+      valid: false,
+      reason: "Combine output depends on strategy. Split requires FlowInput.",
+      note: "Most combine strategies output merged objects/arrays, not FlowInput."
+    },
+    categorize: {
+      valid: true,
+      note: "Can categorize combined results."
+    },
+    extract: {
+      valid: true,
+      note: "Can extract from combined results."
+    },
+    chunk: {
+      valid: true,
+      note: "Can chunk combined DocumentIR. Only valid if combine output is DocumentIR or DocumentIR[]."
+    },
+    combine: {
+      valid: false,
+      reason: "Cannot chain combine nodes. Combine once per forEach operation."
+    },
+    trigger: {
+      valid: true,
+      note: "trigger accepts any input type"
+    },
+    output: {
+      valid: true,
+      note: "output node can follow any node to select or transform results"
+    }
+  },
+  trigger: {
+    parse: {
+      valid: true,
+      requiresRuntimeValidation: true,
+      note: "Valid only if child flow returns FlowInput. Type safety cannot be guaranteed at build-time."
+    },
+    split: {
+      valid: true,
+      requiresRuntimeValidation: true,
+      note: "Valid only if child flow returns FlowInput. Type safety cannot be guaranteed at build-time."
+    },
+    categorize: {
+      valid: true,
+      requiresRuntimeValidation: true,
+      note: "Valid only if child flow returns DocumentIR or FlowInput. Type safety cannot be guaranteed at build-time."
+    },
+    extract: {
+      valid: true,
+      requiresRuntimeValidation: true,
+      note: "Valid only if child flow returns DocumentIR, FlowInput, or ChunkOutput. Type safety cannot be guaranteed at build-time."
+    },
+    chunk: {
+      valid: true,
+      requiresRuntimeValidation: true,
+      note: "Valid only if child flow returns DocumentIR or DocumentIR[]. Type safety cannot be guaranteed at build-time."
+    },
+    combine: {
+      valid: true,
+      requiresRuntimeValidation: true,
+      note: "Valid only if child flow returns an array (T[]). Type safety cannot be guaranteed at build-time."
+    },
+    trigger: {
+      valid: true,
+      requiresRuntimeValidation: true,
+      note: "Can nest trigger nodes (with circular dependency detection and max depth limits). Output type depends on nested child flow."
+    },
+    output: {
+      valid: true,
+      note: "output node can follow any node to select or transform results"
+    }
+  },
+  output: {
+    parse: {
+      valid: false,
+      reason: "Output is a terminal node that selects/transforms results. Cannot chain to other nodes."
+    },
+    split: {
+      valid: false,
+      reason: "Output is a terminal node that selects/transforms results. Cannot chain to other nodes."
+    },
+    categorize: {
+      valid: false,
+      reason: "Output is a terminal node that selects/transforms results. Cannot chain to other nodes."
+    },
+    extract: {
+      valid: false,
+      reason: "Output is a terminal node that selects/transforms results. Cannot chain to other nodes."
+    },
+    chunk: {
+      valid: false,
+      reason: "Output is a terminal node that selects/transforms results. Cannot chain to other nodes."
+    },
+    combine: {
+      valid: false,
+      reason: "Output is a terminal node that selects/transforms results. Cannot chain to other nodes."
+    },
+    trigger: {
+      valid: false,
+      reason: "Output is a terminal node that selects/transforms results. Cannot chain to other nodes."
+    },
+    output: {
+      valid: true,
+      note: "Multiple output nodes are allowed to create multiple named outputs from a flow."
+    }
+  }
+};
+function getNodeTypeName(node2) {
+  if (!node2 || !node2.key) return null;
+  const key = node2.key;
+  const knownTypes = ["parse", "split", "categorize", "extract", "chunk", "combine", "trigger", "output"];
+  return knownTypes.includes(key) ? key : null;
+}
+function getNodeTypeInfo(node2) {
+  return node2.__meta || null;
+}
+function getCompatibleTargets(sourceType, includeForEach = false) {
+  const rules = NODE_COMPATIBILITY_MATRIX[sourceType];
+  if (!rules) return [];
+  return Object.entries(rules).filter(([_, rule]) => {
+    if (!rule.valid) return false;
+    if (rule.requiresForEach && !includeForEach) return false;
+    return true;
+  }).map(([targetType, _]) => targetType);
+}
+function getSuggestedConnections(sourceType) {
+  const compatibleTargets = getCompatibleTargets(sourceType, false);
+  const forEachTargets = getCompatibleTargets(sourceType, true).filter(
+    (t) => !compatibleTargets.includes(t)
+  );
+  if (compatibleTargets.length === 0 && forEachTargets.length === 0) {
+    return [`${sourceType} has no standard outgoing connections (terminal node).`];
+  }
+  const suggestions = [];
+  if (compatibleTargets.length > 0) {
+    suggestions.push(`${sourceType} can connect to:`);
+    compatibleTargets.forEach((target) => {
+      const rule = NODE_COMPATIBILITY_MATRIX[sourceType][target];
+      suggestions.push(`  \u2022 ${target}${rule.note ? ` - ${rule.note}` : ""}`);
+    });
+  }
+  if (forEachTargets.length > 0) {
+    suggestions.push(`${sourceType} can connect to (with forEach enabled):`);
+    forEachTargets.forEach((target) => {
+      const rule = NODE_COMPATIBILITY_MATRIX[sourceType][target];
+      suggestions.push(`  \u2022 ${target}${rule.note ? ` - ${rule.note}` : ""}`);
+    });
+  }
+  return suggestions;
+}
+function validateNodeConnection(sourceType, targetType, forEachEnabled = false) {
+  const rule = NODE_COMPATIBILITY_MATRIX[sourceType]?.[targetType];
+  if (!rule) {
+    return {
+      valid: false,
+      reason: `Unknown node type combination: ${sourceType} \u2192 ${targetType}`,
+      suggestions: ["Ensure both nodes are valid node types."]
+    };
+  }
+  if (!rule.valid) {
+    return {
+      valid: false,
+      reason: rule.reason,
+      suggestions: getSuggestedConnections(sourceType)
+    };
+  }
+  if (rule.requiresForEach && !forEachEnabled) {
+    return {
+      valid: false,
+      reason: `Cannot connect ${sourceType} to ${targetType} without forEach enabled.`,
+      suggestions: [
+        `Enable forEach on the ${sourceType} node:`,
+        `  1. Click the ${sourceType} node`,
+        `  2. Enable "forEach Processing" in the configuration`,
+        `  3. Try connecting again`,
+        "",
+        ...getSuggestedConnections(sourceType)
+      ],
+      requiresForEach: true
+    };
+  }
+  if (rule.requiresRuntimeValidation) {
+    return {
+      valid: true,
+      warning: `\u26A0\uFE0F  ${sourceType} \u2192 ${targetType}: ${rule.note || "Type compatibility depends on runtime values and cannot be validated at build-time."}`
+    };
+  }
+  return {
+    valid: true
+  };
+}
+function getValidForEachStarters(parentType) {
+  const rules = NODE_COMPATIBILITY_MATRIX[parentType];
+  if (!rules) return [];
+  return Object.entries(rules).filter(([_, rule]) => rule.valid && rule.requiresForEach).map(([targetType, _]) => targetType);
+}
+function canStartForEachItemFlow(parentType, starterType) {
+  const rule = NODE_COMPATIBILITY_MATRIX[parentType]?.[starterType];
+  if (!rule) {
+    return {
+      valid: false,
+      reason: `Unknown node type combination: ${parentType} \u2192 forEach \u2192 ${starterType}`,
+      suggestions: ["Ensure both nodes are valid node types."]
+    };
+  }
+  if (rule.valid && rule.requiresForEach) {
+    return {
+      valid: true
+    };
+  }
+  if (!rule.valid) {
+    const validStarters2 = getValidForEachStarters(parentType);
+    return {
+      valid: false,
+      reason: `${starterType} cannot start forEach itemFlow after ${parentType}. ${rule.reason || "Type incompatible with forEach unwrapped item."}`,
+      suggestions: validStarters2.length > 0 ? [`Valid itemFlow starters for ${parentType}: ${validStarters2.join(", ")}`] : [`${parentType} has no valid forEach itemFlow starters.`]
+    };
+  }
+  const validStarters = getValidForEachStarters(parentType);
+  return {
+    valid: false,
+    reason: `${starterType} cannot start forEach itemFlow after ${parentType}. This connection does not require forEach, meaning it expects the full array, not individual items.`,
+    suggestions: validStarters.length > 0 ? [`Valid itemFlow starters for ${parentType}: ${validStarters.join(", ")}`] : [`${parentType} has no valid forEach itemFlow starters.`]
+  };
+}
+function validateJson(data, schema) {
+  const errors = [];
+  const MAX_DEPTH = 50;
+  function validate(value, schema2, path = "", depth = 0) {
+    if (depth > MAX_DEPTH) {
+      errors.push(`${path || "root"}: maximum nesting depth (${MAX_DEPTH}) exceeded`);
+      return;
+    }
+    if (schema2.nullable && (value === null || value === void 0)) {
+      return;
+    }
+    if (value === null || value === void 0) {
+      if (schema2.nullable !== true) {
+        errors.push(`${path || "root"}: value is null or undefined`);
+      }
+      return;
+    }
+    const actualType = Array.isArray(value) ? "array" : typeof value;
+    const expectedType = schema2.type;
+    if (expectedType) {
+      if (expectedType === "integer") {
+        if (typeof value !== "number" || !Number.isInteger(value)) {
+          errors.push(`${path || "root"}: expected integer, got ${actualType}`);
+          return;
+        }
+      } else if (expectedType === "number") {
+        if (typeof value !== "number") {
+          errors.push(`${path || "root"}: expected number, got ${actualType}`);
+          return;
+        }
+      } else if (expectedType === "string") {
+        if (typeof value !== "string") {
+          errors.push(`${path || "root"}: expected string, got ${actualType}`);
+          return;
+        }
+      } else if (expectedType === "boolean") {
+        if (typeof value !== "boolean") {
+          errors.push(`${path || "root"}: expected boolean, got ${actualType}`);
+          return;
+        }
+      } else if (expectedType === "object") {
+        if (typeof value !== "object" || Array.isArray(value)) {
+          errors.push(`${path || "root"}: expected object, got ${actualType}`);
+          return;
+        }
+        if (schema2.required && Array.isArray(schema2.required)) {
+          for (const reqProp of schema2.required) {
+            if (!(reqProp in value)) {
+              errors.push(`${path}.${reqProp}: required property missing`);
+            }
+          }
+        }
+        const dangerousProps = ["__proto__", "constructor", "prototype"];
+        if (schema2.additionalProperties === false && schema2.properties) {
+          const allowedProps = Object.keys(schema2.properties);
+          const requiredProps = schema2.required || [];
+          const allAllowedProps = /* @__PURE__ */ new Set([...allowedProps, ...requiredProps]);
+          for (const key of [...Object.keys(value), ...Object.getOwnPropertyNames(value)]) {
+            if (dangerousProps.includes(key)) {
+              errors.push(`${path}.${key}: dangerous property not allowed`);
+              continue;
+            }
+            if (!allAllowedProps.has(key)) {
+              errors.push(`${path}.${key}: additional property not allowed`);
+            }
+          }
+        } else {
+          for (const key of dangerousProps) {
+            if (key in value && Object.prototype.hasOwnProperty.call(value, key)) {
+              errors.push(`${path}.${key}: dangerous property not allowed`);
+            }
+          }
+        }
+        if (schema2.properties) {
+          const valueObj = value;
+          for (const [propName, propSchema] of Object.entries(schema2.properties)) {
+            if (propName in valueObj) {
+              validate(valueObj[propName], propSchema, path ? `${path}.${propName}` : propName, depth + 1);
+            }
+          }
+        }
+      } else if (expectedType === "array") {
+        if (!Array.isArray(value)) {
+          errors.push(`${path || "root"}: expected array, got ${actualType}`);
+          return;
+        }
+        if (schema2.items && !Array.isArray(schema2.items)) {
+          const itemSchema = schema2.items;
+          value.forEach((item, index) => {
+            validate(item, itemSchema, `${path}[${index}]`, depth + 1);
+          });
+        }
+      }
+    }
+  }
+  validate(data, schema);
+  if (errors.length > 0) {
+    throw new Error(`Schema validation failed:
+${errors.join("\n")}`);
+  }
+  return data;
+}
+var RESERVED_VARIABLES = {
+  extract: ["schema", "documentText", "schemaTitle", "schemaDescription", "structuredFormat"],
+  categorize: ["categories", "documentText"],
+  parse: ["format", "schema", "describeFigures", "citationsEnabled"]
+};
+function protectReservedVariables(nodeType, userVariables, autoInjectedVariables) {
+  if (!userVariables || Object.keys(userVariables).length === 0) {
+    return autoInjectedVariables;
+  }
+  const reserved = RESERVED_VARIABLES[nodeType];
+  const warnings = [];
+  for (const key of reserved) {
+    if (key in userVariables) {
+      warnings.push(key);
+    }
+  }
+  if (warnings.length > 0) {
+    console.warn(
+      `[doclo] Attempted to override reserved variables in ${nodeType} node: ${warnings.join(", ")}. These variables are auto-injected from config and cannot be overridden. They will be ignored.`
+    );
+  }
+  return {
+    ...autoInjectedVariables,
+    ...userVariables,
+    // Restore reserved variables to ensure they can't be overridden
+    ...Object.fromEntries(
+      reserved.map((key) => [key, autoInjectedVariables[key]])
+    )
+  };
+}
+
+// src/security/url-validator.ts
+var BLOCKED_IP_RANGES = [
+  // Loopback
+  { start: "127.0.0.0", end: "127.255.255.255" },
+  // Private Class A
+  { start: "10.0.0.0", end: "10.255.255.255" },
+  // Private Class B
+  { start: "172.16.0.0", end: "172.31.255.255" },
+  // Private Class C
+  { start: "192.168.0.0", end: "192.168.255.255" },
+  // Link Local
+  { start: "169.254.0.0", end: "169.254.255.255" }
+];
+var BLOCKED_METADATA_HOSTS = [
+  "169.254.169.254",
+  // AWS metadata service
+  "169.254.169.253",
+  // AWS metadata service (Windows)
+  "metadata.google.internal",
+  // GCP metadata service
+  "metadata",
+  // GCP alias
+  "100.100.100.200",
+  // Aliyun metadata service
+  "instance-data"
+  // OpenStack alias
+];
+var BLOCKED_IPV6_PATTERNS = [
+  /^::1$/,
+  // Loopback (::1)
+  /^::$/,
+  // Any address (::)
+  /^::ffff:/i,
+  // IPv4-mapped IPv6 (::ffff:0:0/96) - matches ::ffff:127.0.0.1
+  /^::ffff:0:/i,
+  // IPv4-mapped IPv6 alternative
+  /^fe80:/i,
+  // Link-local (fe80::/10)
+  /^fec0:/i,
+  // Site-local deprecated (fec0::/10)
+  /^fc00:/i,
+  // Unique local address (fc00::/7)
+  /^fd00:/i,
+  // Unique local address (fd00::/8)
+  /^ff00:/i,
+  // Multicast (ff00::/8)
+  /^0:0:0:0:0:0:0:1$/i
+  // Loopback expanded form
+];
+function ipToNumber(ip) {
+  const parts = ip.split(".").map(Number);
+  if (parts.length !== 4 || parts.some((p) => p < 0 || p > 255)) {
+    return -1;
+  }
+  return (parts[0] << 24) + (parts[1] << 16) + (parts[2] << 8) + parts[3];
+}
+function isIpInBlockedRange(ip) {
+  const ipNum = ipToNumber(ip);
+  if (ipNum === -1) return false;
+  return BLOCKED_IP_RANGES.some((range) => {
+    const startNum = ipToNumber(range.start);
+    const endNum = ipToNumber(range.end);
+    return ipNum >= startNum && ipNum <= endNum;
+  });
+}
+function isIPv6Blocked(hostname) {
+  const addr = hostname.replace(/^\[|\]$/g, "");
+  return BLOCKED_IPV6_PATTERNS.some((pattern) => pattern.test(addr));
+}
+function validateUrl(urlString, options = {}) {
+  const {
+    blockInternal = true,
+    allowedProtocols = ["http:", "https:"]
+  } = options;
+  let url;
+  try {
+    url = new URL(urlString);
+  } catch (error) {
+    throw new Error(`Invalid URL: ${urlString}`);
+  }
+  if (!allowedProtocols.includes(url.protocol)) {
+    throw new Error(
+      `Blocked protocol: ${url.protocol}. Allowed: ${allowedProtocols.join(", ")}`
+    );
+  }
+  if (blockInternal) {
+    const hostname = url.hostname;
+    if (BLOCKED_METADATA_HOSTS.includes(hostname)) {
+      throw new Error(`Blocked metadata service: ${hostname}`);
+    }
+    if (hostname.includes(":") || hostname.startsWith("[")) {
+      if (isIPv6Blocked(hostname)) {
+        throw new Error(`Blocked IPv6 address: ${hostname}`);
+      }
+    }
+    if (isIpInBlockedRange(hostname)) {
+      throw new Error(`Blocked internal IP address: ${hostname}`);
+    }
+    if (hostname === "localhost") {
+      throw new Error("Blocked localhost access");
+    }
+  }
+  return url;
+}
+
+// src/security/resource-limits.ts
+var DEFAULT_LIMITS = {
+  // Maximum file size: 100MB
+  MAX_FILE_SIZE: 100 * 1024 * 1024,
+  // Request timeout: 30 seconds
+  REQUEST_TIMEOUT: 3e4,
+  // Maximum JSON parse depth
+  MAX_JSON_DEPTH: 100
+};
+function validateFileSize(size, maxSize = DEFAULT_LIMITS.MAX_FILE_SIZE) {
+  if (size > maxSize) {
+    const maxMB = Math.round(maxSize / 1024 / 1024);
+    const sizeMB = Math.round(size / 1024 / 1024);
+    throw new Error(
+      `File size ${sizeMB}MB exceeds maximum allowed size of ${maxMB}MB`
+    );
+  }
+}
+function createFetchController(timeoutMs = DEFAULT_LIMITS.REQUEST_TIMEOUT) {
+  const controller = new AbortController();
+  const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
+  controller.__timeoutId = timeoutId;
+  return controller;
+}
+function cleanupFetchController(controller) {
+  const timeoutId = controller.__timeoutId;
+  if (timeoutId) {
+    clearTimeout(timeoutId);
+  }
+}
+async function fetchWithTimeout(url, options = {}, timeoutMs = DEFAULT_LIMITS.REQUEST_TIMEOUT) {
+  const controller = createFetchController(timeoutMs);
+  try {
+    const response = await fetch(url, {
+      ...options,
+      signal: controller.signal,
+      cache: "no-store"
+      // Prevent Next.js cache revalidation which can cause AbortError (see: github.com/vercel/next.js/issues/54045)
+    });
+    return response;
+  } finally {
+    cleanupFetchController(controller);
+  }
+}
+
+// src/runtime/base64.ts
+function arrayBufferToBase64(buffer) {
+  if (typeof Buffer !== "undefined") {
+    return Buffer.from(buffer).toString("base64");
+  }
+  const bytes = new Uint8Array(buffer);
+  let binary = "";
+  for (let i = 0; i < bytes.byteLength; i++) {
+    binary += String.fromCharCode(bytes[i]);
+  }
+  return btoa(binary);
+}
+function base64ToArrayBuffer(base64) {
+  const cleanBase64 = base64.replace(/^data:[^;]+;base64,/, "");
+  if (typeof Buffer !== "undefined") {
+    const buffer = Buffer.from(cleanBase64, "base64");
+    return buffer.buffer.slice(buffer.byteOffset, buffer.byteOffset + buffer.byteLength);
+  }
+  const binaryString = atob(cleanBase64);
+  const bytes = new Uint8Array(binaryString.length);
+  for (let i = 0; i < binaryString.length; i++) {
+    bytes[i] = binaryString.charCodeAt(i);
+  }
+  return bytes.buffer;
+}
+function uint8ArrayToBase64(bytes) {
+  return arrayBufferToBase64(bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength));
+}
+function createDataUri(buffer, mimeType = "application/octet-stream") {
+  const base64 = arrayBufferToBase64(buffer);
+  return `data:${mimeType};base64,${base64}`;
+}
+
+// src/mime-detection.ts
+import { fileTypeFromBuffer } from "file-type";
+async function detectMimeTypeFromBase64Async(base64Data) {
+  const base64Only = base64Data.includes(",") ? base64Data.split(",")[1] : base64Data;
+  const binaryString = atob(base64Only);
+  const bytes = new Uint8Array(binaryString.length);
+  for (let i = 0; i < binaryString.length; i++) {
+    bytes[i] = binaryString.charCodeAt(i);
+  }
+  const result = await fileTypeFromBuffer(bytes);
+  if (result) {
+    return result.mime;
+  }
+  throw new Error(
+    `Unsupported file format. Magic bytes: ${Array.from(bytes.slice(0, 4)).map((b) => b.toString(16).padStart(2, "0")).join(" ")}`
+  );
+}
+function detectMimeTypeFromBase64(base64Data) {
+  const base64Only = base64Data.includes(",") ? base64Data.split(",")[1] : base64Data;
+  const binaryString = atob(base64Only.substring(0, 24));
+  const bytes = new Uint8Array(binaryString.length);
+  for (let i = 0; i < binaryString.length; i++) {
+    bytes[i] = binaryString.charCodeAt(i);
+  }
+  return detectMimeTypeFromBytes(bytes);
+}
+function detectMimeTypeFromBytes(bytes) {
+  if (bytes.length < 4) {
+    throw new Error("Insufficient data to detect MIME type (need at least 4 bytes)");
+  }
+  if (bytes[0] === 255 && bytes[1] === 216 && bytes[2] === 255) {
+    return "image/jpeg";
+  }
+  if (bytes[0] === 137 && bytes[1] === 80 && bytes[2] === 78 && bytes[3] === 71) {
+    return "image/png";
+  }
+  if (bytes[0] === 71 && bytes[1] === 73 && bytes[2] === 70 && bytes[3] === 56) {
+    return "image/gif";
+  }
+  if (bytes.length >= 12 && bytes[0] === 82 && bytes[1] === 73 && bytes[2] === 70 && bytes[3] === 70 && bytes[8] === 87 && bytes[9] === 69 && bytes[10] === 66 && bytes[11] === 80) {
+    return "image/webp";
+  }
+  if (bytes[0] === 37 && bytes[1] === 80 && bytes[2] === 68 && bytes[3] === 70) {
+    return "application/pdf";
+  }
+  if (bytes[0] === 73 && bytes[1] === 73 && bytes[2] === 42 && bytes[3] === 0 || bytes[0] === 77 && bytes[1] === 77 && bytes[2] === 0 && bytes[3] === 42) {
+    return "image/tiff";
+  }
+  if (bytes[0] === 66 && bytes[1] === 77) {
+    return "image/bmp";
+  }
+  if (bytes[0] === 123 && bytes[1] === 92 && bytes[2] === 114 && bytes[3] === 116 && bytes[4] === 102) {
+    return "application/rtf";
+  }
+  if (bytes[0] === 80 && bytes[1] === 75 && bytes[2] === 3 && bytes[3] === 4) {
+    return "application/zip";
+  }
+  if (bytes.length >= 8 && bytes[0] === 208 && bytes[1] === 207 && bytes[2] === 17 && bytes[3] === 224 && bytes[4] === 161 && bytes[5] === 177 && bytes[6] === 26 && bytes[7] === 225) {
+    return "application/x-cfb";
+  }
+  throw new Error(
+    `Unsupported file format. Magic bytes: ${Array.from(bytes.slice(0, 4)).map((b) => b.toString(16).padStart(2, "0")).join(" ")}`
+  );
+}
+function validateMimeType(base64Data, declaredMimeType) {
+  const actualMimeType = detectMimeTypeFromBase64(base64Data);
+  return {
+    isValid: actualMimeType === declaredMimeType,
+    actualMimeType,
+    declaredMimeType
+  };
+}
+async function validateMimeTypeAsync(base64Data, declaredMimeType) {
+  const actualMimeType = await detectMimeTypeFromBase64Async(base64Data);
+  return {
+    isValid: actualMimeType === declaredMimeType,
+    actualMimeType,
+    declaredMimeType
+  };
+}
+function extractBase64(data) {
+  if (data.startsWith("data:")) {
+    const commaIndex = data.indexOf(",");
+    if (commaIndex === -1) {
+      throw new Error("Invalid data URI: missing comma separator");
+    }
+    return data.substring(commaIndex + 1);
+  }
+  return data;
+}
+
+// src/internal/file-utils.ts
+function detectInputType(input) {
+  if (input.startsWith("data:")) return "data-uri";
+  if (input.startsWith("http://") || input.startsWith("https://")) return "url";
+  throw new Error(
+    'Edge Runtime does not support file paths. Use HTTP URLs, data URIs, or pass ArrayBuffer/base64 data directly.\nExample: await resolveDocument("https://example.com/doc.pdf") or resolveDocument("data:application/pdf;base64,...")'
+  );
+}
+function detectMimeType(input, contentType) {
+  if (input.startsWith("data:")) {
+    const match = input.match(/^data:([^;,]+)/);
+    if (match) return match[1];
+  }
+  if (contentType) {
+    const match = contentType.match(/^([^;]+)/);
+    if (match) return match[1].trim();
+  }
+  const lower = input.toLowerCase();
+  if (lower.endsWith(".pdf") || lower.includes(".pdf?")) return "application/pdf";
+  if (lower.endsWith(".png") || lower.includes(".png?")) return "image/png";
+  if (lower.endsWith(".webp") || lower.includes(".webp?")) return "image/webp";
+  if (lower.endsWith(".jpg") || lower.includes(".jpg?")) return "image/jpeg";
+  if (lower.endsWith(".jpeg") || lower.includes(".jpeg?")) return "image/jpeg";
+  if (lower.endsWith(".gif") || lower.includes(".gif?")) return "image/gif";
+  if (lower.endsWith(".tiff") || lower.includes(".tiff?")) return "image/tiff";
+  if (lower.endsWith(".tif") || lower.includes(".tif?")) return "image/tiff";
+  if (lower.endsWith(".bmp") || lower.includes(".bmp?")) return "image/bmp";
+  if (lower.endsWith(".heic") || lower.includes(".heic?")) return "image/heic";
+  if (lower.endsWith(".heif") || lower.includes(".heif?")) return "image/heif";
+  if (lower.endsWith(".psd") || lower.includes(".psd?")) return "image/vnd.adobe.photoshop";
+  if (lower.endsWith(".doc") || lower.includes(".doc?")) return "application/msword";
+  if (lower.endsWith(".docx") || lower.includes(".docx?")) return "application/vnd.openxmlformats-officedocument.wordprocessingml.document";
+  if (lower.endsWith(".xls") || lower.includes(".xls?")) return "application/vnd.ms-excel";
+  if (lower.endsWith(".xlsx") || lower.includes(".xlsx?")) return "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet";
+  if (lower.endsWith(".ppt") || lower.includes(".ppt?")) return "application/vnd.ms-powerpoint";
+  if (lower.endsWith(".pptx") || lower.includes(".pptx?")) return "application/vnd.openxmlformats-officedocument.presentationml.presentation";
+  if (lower.endsWith(".odt") || lower.includes(".odt?")) return "application/vnd.oasis.opendocument.text";
+  if (lower.endsWith(".ods") || lower.includes(".ods?")) return "application/vnd.oasis.opendocument.spreadsheet";
+  if (lower.endsWith(".odp") || lower.includes(".odp?")) return "application/vnd.oasis.opendocument.presentation";
+  if (lower.endsWith(".txt") || lower.includes(".txt?")) return "text/plain";
+  if (lower.endsWith(".csv") || lower.includes(".csv?")) return "text/csv";
+  if (lower.endsWith(".html") || lower.includes(".html?")) return "text/html";
+  if (lower.endsWith(".htm") || lower.includes(".htm?")) return "text/html";
+  if (lower.endsWith(".rtf") || lower.includes(".rtf?")) return "application/rtf";
+  if (lower.endsWith(".epub") || lower.includes(".epub?")) return "application/epub+zip";
+  return "application/octet-stream";
+}
+var KNOWN_MIME_TYPES = [
+  // PDF
+  "application/pdf",
+  // Images - common
+  "image/jpeg",
+  "image/png",
+  "image/gif",
+  "image/webp",
+  // Images - additional
+  "image/tiff",
+  "image/bmp",
+  "image/heic",
+  "image/heif",
+  "image/vnd.adobe.photoshop",
+  // Microsoft Office
+  "application/msword",
+  "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+  "application/vnd.ms-excel",
+  "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+  "application/vnd.ms-powerpoint",
+  "application/vnd.openxmlformats-officedocument.presentationml.presentation",
+  // OpenDocument formats
+  "application/vnd.oasis.opendocument.text",
+  "application/vnd.oasis.opendocument.spreadsheet",
+  "application/vnd.oasis.opendocument.presentation",
+  // Text formats
+  "text/plain",
+  "text/csv",
+  "text/html",
+  "application/rtf",
+  // Other
+  "application/epub+zip"
+];
+var EXTENSION_TO_MIME = {
+  // PDF
+  ".pdf": "application/pdf",
+  // Images - common
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".png": "image/png",
+  ".gif": "image/gif",
+  ".webp": "image/webp",
+  // Images - additional
+  ".tiff": "image/tiff",
+  ".tif": "image/tiff",
+  ".bmp": "image/bmp",
+  ".heic": "image/heic",
+  ".heif": "image/heif",
+  ".psd": "image/vnd.adobe.photoshop",
+  // Microsoft Office
+  ".doc": "application/msword",
+  ".docx": "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+  ".xls": "application/vnd.ms-excel",
+  ".xlsx": "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+  ".ppt": "application/vnd.ms-powerpoint",
+  ".pptx": "application/vnd.openxmlformats-officedocument.presentationml.presentation",
+  // OpenDocument formats
+  ".odt": "application/vnd.oasis.opendocument.text",
+  ".ods": "application/vnd.oasis.opendocument.spreadsheet",
+  ".odp": "application/vnd.oasis.opendocument.presentation",
+  // Text formats
+  ".txt": "text/plain",
+  ".csv": "text/csv",
+  ".html": "text/html",
+  ".htm": "text/html",
+  ".rtf": "application/rtf",
+  // Other
+  ".epub": "application/epub+zip"
+};
+function getExtensionFromPath(path) {
+  const pathWithoutQuery = path.split("?")[0];
+  const lastDot = pathWithoutQuery.lastIndexOf(".");
+  if (lastDot === -1) return null;
+  return pathWithoutQuery.slice(lastDot).toLowerCase();
+}
+function detectDocumentType(input) {
+  if (!input) return "unknown";
+  if (input.startsWith("data:")) {
+    const match = input.match(/^data:([^;,]+)/);
+    if (match) {
+      const mimeType = match[1];
+      if (KNOWN_MIME_TYPES.includes(mimeType)) {
+        return mimeType;
+      }
+    }
+  }
+  if (!input.startsWith("data:")) {
+    let ext = null;
+    try {
+      const url = new URL(input);
+      ext = getExtensionFromPath(url.pathname);
+    } catch {
+      ext = getExtensionFromPath(input);
+    }
+    if (ext && ext in EXTENSION_TO_MIME) {
+      return EXTENSION_TO_MIME[ext];
+    }
+  }
+  try {
+    const mimeType = detectMimeTypeFromBase64(input);
+    if (KNOWN_MIME_TYPES.includes(mimeType)) {
+      return mimeType;
+    }
+  } catch {
+  }
+  return "unknown";
+}
+function isPDFDocument(input) {
+  return detectDocumentType(input) === "application/pdf";
+}
+async function resolveDocument(input, limits) {
+  const inputType = detectInputType(input);
+  switch (inputType) {
+    case "data-uri":
+      if (!input.match(/^data:[^;,]+;base64,/)) {
+        throw new Error("Invalid data URI format. Expected: data:<mimetype>;base64,<data>");
+      }
+      return input;
+    case "url":
+      try {
+        validateUrl(input);
+        const timeout = limits?.requestTimeout ?? DEFAULT_LIMITS.REQUEST_TIMEOUT;
+        const response = await fetchWithTimeout(input, {}, timeout);
+        if (!response.ok) {
+          throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+        }
+        const contentLength = response.headers.get("content-length");
+        if (contentLength) {
+          const maxSize2 = limits?.maxFileSize ?? DEFAULT_LIMITS.MAX_FILE_SIZE;
+          validateFileSize(parseInt(contentLength, 10), maxSize2);
+        }
+        const arrayBuffer = await response.arrayBuffer();
+        const maxSize = limits?.maxFileSize ?? DEFAULT_LIMITS.MAX_FILE_SIZE;
+        validateFileSize(arrayBuffer.byteLength, maxSize);
+        const base64 = arrayBufferToBase64(arrayBuffer);
+        const mimeType = detectMimeType(input, response.headers.get("content-type") || void 0);
+        return `data:${mimeType};base64,${base64}`;
+      } catch (error) {
+        throw new Error(`Failed to fetch URL ${input}: ${error.message}`);
+      }
+  }
+}
+function bufferToDataUri(buffer, mimeType) {
+  if (buffer instanceof Uint8Array) {
+    const arrayBuffer = buffer.buffer.slice(buffer.byteOffset, buffer.byteOffset + buffer.byteLength);
+    return createDataUri(arrayBuffer, mimeType);
+  }
+  return createDataUri(buffer, mimeType);
+}
+function bufferToBase64(buffer, mimeType) {
+  return bufferToDataUri(buffer, mimeType);
+}
+var FlowInputValidationError = class _FlowInputValidationError extends Error {
+  /**
+   * @param message - Human-readable error message
+   * @param detectedType - The actual MIME type detected from the input
+   * @param acceptedTypes - List of MIME types that would have been accepted
+   */
+  constructor(message, detectedType, acceptedTypes) {
+    super(message);
+    this.detectedType = detectedType;
+    this.acceptedTypes = acceptedTypes;
+    this.name = "FlowInputValidationError";
+    Object.setPrototypeOf(this, _FlowInputValidationError.prototype);
+  }
+};
+function validateFlowInputFormat(input, acceptedFormats) {
+  if (!input) {
+    throw new FlowInputValidationError(
+      "Flow input is empty or undefined",
+      "undefined",
+      acceptedFormats
+    );
+  }
+  const detected = detectDocumentType(input);
+  if (detected === "unknown") {
+    const acceptedList = acceptedFormats.length > 0 ? `Expected one of: ${acceptedFormats.join(", ")}` : "Unable to determine document format";
+    throw new FlowInputValidationError(
+      `Unable to detect document format. ${acceptedList}. Ensure the input is a valid document (PDF, JPEG, PNG, GIF, or WebP).`,
+      "unknown",
+      acceptedFormats
+    );
+  }
+  if (acceptedFormats.length > 0 && !acceptedFormats.includes(detected)) {
+    throw new FlowInputValidationError(
+      `Document format '${detected}' is not accepted. Expected one of: ${acceptedFormats.join(", ")}`,
+      detected,
+      acceptedFormats
+    );
+  }
+  return detected;
+}
+
+// src/pdf-utils.ts
+import { PDFDocument } from "pdf-lib";
+async function getPDFPageCount(dataUrl) {
+  const base64Match = dataUrl.match(/^data:application\/pdf;base64,(.+)$/);
+  if (!base64Match) {
+    throw new Error("Invalid PDF data URL format. Expected: data:application/pdf;base64,{base64data}");
+  }
+  const base64Data = base64Match[1];
+  const pdfBytes = base64ToArrayBuffer(base64Data);
+  const pdfDoc = await PDFDocument.load(pdfBytes);
+  return pdfDoc.getPageCount();
+}
+async function splitPDFIntoChunks(dataUrl, pageRanges) {
+  const base64Match = dataUrl.match(/^data:application\/pdf;base64,(.+)$/);
+  if (!base64Match) {
+    throw new Error("Invalid PDF data URL format. Expected: data:application/pdf;base64,{base64data}");
+  }
+  const base64Data = base64Match[1];
+  const pdfBytes = base64ToArrayBuffer(base64Data);
+  const pdfDoc = await PDFDocument.load(pdfBytes);
+  const totalPages = pdfDoc.getPageCount();
+  const chunks = [];
+  for (const [startPage, endPage] of pageRanges) {
+    if (startPage < 1 || endPage > totalPages || startPage > endPage) {
+      throw new Error(
+        `Invalid page range [${startPage}, ${endPage}] for PDF with ${totalPages} pages. Page numbers must be 1-indexed and within bounds.`
+      );
+    }
+    const chunkDoc = await PDFDocument.create();
+    const pagesToCopy = Array.from(
+      { length: endPage - startPage + 1 },
+      (_, i) => startPage - 1 + i
+      // Convert to 0-indexed
+    );
+    const copiedPages = await chunkDoc.copyPages(pdfDoc, pagesToCopy);
+    copiedPages.forEach((page) => chunkDoc.addPage(page));
+    const chunkBytes = await chunkDoc.save();
+    const chunkBase64 = uint8ArrayToBase64(chunkBytes);
+    chunks.push(`data:application/pdf;base64,${chunkBase64}`);
+  }
+  return chunks;
+}
+function getDocumentPageCount(ir) {
+  if (ir.extras?.pageCount !== void 0) {
+    return ir.extras.pageCount;
+  }
+  return ir.pages.length;
+}
+function getTotalPageCount(irArray) {
+  return irArray.reduce((sum, ir) => sum + getDocumentPageCount(ir), 0);
+}
+function getPageCountMetadata(ir) {
+  const pagesInIR = ir.pages.length;
+  const pageCount = ir.extras?.pageCount ?? pagesInIR;
+  const isSemanticChunking = ir.extras?.totalSemanticChunks !== void 0;
+  const isChunked = ir.extras?.chunkIndex !== void 0 && ir.extras?.totalChunks !== void 0;
+  return {
+    pageCount,
+    pagesInIR,
+    isChunked,
+    chunkIndex: ir.extras?.chunkIndex,
+    totalChunks: ir.extras?.totalChunks,
+    pageRange: ir.extras?.pageRange,
+    totalSemanticChunks: ir.extras?.totalSemanticChunks,
+    isSemanticChunking
+  };
+}
+
+// src/provider-config.ts
+function defineVLMProvider(config) {
+  return {
+    type: "vlm",
+    ...config
+  };
+}
+function defineSuryaProvider(config) {
+  return {
+    type: "ocr",
+    ...config
+  };
+}
+function defineMarkerProvider(config) {
+  return {
+    type: "ocr",
+    ...config
+  };
+}
+async function buildProviderFromConfig(config, secrets) {
+  const secret = secrets[config.id];
+  if (!secret || !secret.apiKey) {
+    throw new Error(`API key not found for provider "${config.id}"`);
+  }
+  if (config.type === "vlm") {
+    try {
+      const module = await import(
+        /* webpackIgnore: true */
+        "@doclo/providers-llm"
+      );
+      const createVLMProvider = module.createVLMProvider || module.default?.createVLMProvider;
+      if (!createVLMProvider) {
+        throw new Error("@doclo/providers-llm does not export createVLMProvider");
+      }
+      return createVLMProvider({
+        provider: config.provider,
+        model: config.model,
+        apiKey: secret.apiKey,
+        via: config.via === "openrouter" ? "openrouter" : void 0,
+        baseUrl: config.baseUrl
+      });
+    } catch (error) {
+      throw new Error(
+        `Failed to create VLM provider: ${error.message}. Make sure @doclo/providers-llm is installed.`
+      );
+    }
+  } else if (config.type === "ocr") {
+    try {
+      const module = await import(
+        /* webpackIgnore: true */
+        "@doclo/providers-datalab"
+      );
+      if (config.provider === "surya") {
+        const suryaProvider = module.suryaProvider || module.default?.suryaProvider;
+        if (!suryaProvider) {
+          throw new Error("@doclo/providers-datalab does not export suryaProvider");
+        }
+        return suryaProvider({
+          endpoint: config.endpoint,
+          apiKey: secret.apiKey
+        });
+      } else if (config.provider === "marker") {
+        const markerProvider = module.markerProvider || module.default?.markerProvider;
+        if (!markerProvider) {
+          throw new Error("@doclo/providers-datalab does not export markerProvider");
+        }
+        return markerProvider({
+          apiKey: secret.apiKey,
+          force_ocr: config.force_ocr,
+          use_llm: config.use_llm
+        });
+      } else {
+        const exhaustiveCheck = config;
+        throw new Error(`Unknown OCR provider: ${exhaustiveCheck.provider}`);
+      }
+    } catch (error) {
+      throw new Error(
+        `Failed to create OCR provider: ${error.message}. Make sure @doclo/providers-datalab is installed.`
+      );
+    }
+  } else {
+    const exhaustiveCheck = config;
+    throw new Error(`Unknown provider type: ${exhaustiveCheck.type}`);
+  }
+}
+async function buildProvidersFromConfigs(configs, secrets) {
+  const registry = {};
+  for (const config of configs) {
+    try {
+      registry[config.id] = await buildProviderFromConfig(config, secrets);
+    } catch (error) {
+      throw new Error(
+        `Failed to build provider "${config.id}": ${error.message}`
+      );
+    }
+  }
+  return registry;
+}
+
+// src/provider-identity.ts
+function toProviderString(identity) {
+  return `${identity.provider}:${identity.model}`;
+}
+function parseProviderString(str) {
+  const colonIndex = str.indexOf(":");
+  if (colonIndex === -1) {
+    return { provider: str, model: str };
+  }
+  return {
+    provider: str.slice(0, colonIndex),
+    model: str.slice(colonIndex + 1)
+  };
+}
+function isLocalEndpoint(endpoint) {
+  if (!endpoint) return false;
+  return endpoint.includes("localhost") || endpoint.includes("127.0.0.1") || endpoint.includes("0.0.0.0") || endpoint.startsWith("http://192.168.") || endpoint.startsWith("http://10.");
+}
+function createIdentity(provider, model, opts) {
+  let method = "native";
+  if (opts?.via === "openrouter") {
+    method = "openrouter";
+  } else if (isLocalEndpoint(opts?.endpoint)) {
+    method = "self-hosted";
+  }
+  return { provider, model, method };
+}
+
+// src/provider-query.ts
+var providerRegistry = /* @__PURE__ */ new Map();
+function registerProviderMetadata(source, metadata, normalizer) {
+  const normalized = /* @__PURE__ */ new Map();
+  for (const [id, data] of Object.entries(metadata)) {
+    if (normalizer) {
+      normalized.set(id, normalizer(id, data, source));
+    } else {
+      normalized.set(id, defaultNormalizer(id, data, source));
+    }
+  }
+  providerRegistry.set(source, normalized);
+}
+function getAllProviders() {
+  const all = [];
+  for (const providers of providerRegistry.values()) {
+    all.push(...providers.values());
+  }
+  return all;
+}
+function queryProviders(filter = {}) {
+  let providers = getAllProviders();
+  if (filter.source) {
+    const sources = Array.isArray(filter.source) ? filter.source : [filter.source];
+    providers = providers.filter((p) => sources.includes(p.source));
+  }
+  if (filter.type) {
+    const types = Array.isArray(filter.type) ? filter.type : [filter.type];
+    providers = providers.filter((p) => types.includes(p.type));
+  }
+  if (filter.provider) {
+    const providerVendors = Array.isArray(filter.provider) ? filter.provider : [filter.provider];
+    providers = providers.filter((p) => p.identity?.provider && providerVendors.includes(p.identity.provider));
+  }
+  if (filter.model) {
+    const models = Array.isArray(filter.model) ? filter.model : [filter.model];
+    providers = providers.filter((p) => p.identity?.model && models.includes(p.identity.model));
+  }
+  if (filter.method) {
+    const methods = Array.isArray(filter.method) ? filter.method : [filter.method];
+    providers = providers.filter((p) => p.identity?.method && methods.includes(p.identity.method));
+  }
+  if (filter.supports) {
+    if (filter.supports.images !== void 0) {
+      providers = providers.filter((p) => p.capabilities.supportsImages === filter.supports.images);
+    }
+    if (filter.supports.pdfs !== void 0) {
+      providers = providers.filter((p) => p.capabilities.supportsPDFs === filter.supports.pdfs);
+    }
+    if (filter.supports.documents !== void 0) {
+      providers = providers.filter((p) => p.capabilities.supportsDocuments === filter.supports.documents);
+    }
+    if (filter.supports.reasoning !== void 0) {
+      providers = providers.filter((p) => p.capabilities.supportsReasoning === filter.supports.reasoning);
+    }
+    if (filter.supports.structuredOutput !== void 0) {
+      providers = providers.filter((p) => p.capabilities.supportsStructuredOutput === filter.supports.structuredOutput);
+    }
+    if (filter.supports.prompts !== void 0) {
+      providers = providers.filter((p) => p.capabilities.supportsPrompts === filter.supports.prompts);
+    }
+    if (filter.supports.citations !== void 0) {
+      providers = providers.filter((p) => p.capabilities.supportsCitations === filter.supports.citations);
+    }
+    if (filter.supports.chunking !== void 0) {
+      providers = providers.filter((p) => p.capabilities.supportsChunking === filter.supports.chunking);
+    }
+    if (filter.supports.imageExtraction !== void 0) {
+      providers = providers.filter((p) => p.capabilities.supportsImageExtraction === filter.supports.imageExtraction);
+    }
+    if (filter.supports.pageMarkers !== void 0) {
+      providers = providers.filter((p) => p.capabilities.supportsPageMarkers === filter.supports.pageMarkers);
+    }
+    if (filter.supports.languageHints !== void 0) {
+      providers = providers.filter((p) => p.capabilities.supportsLanguageHints === filter.supports.languageHints);
+    }
+    if (filter.supports.processingModes !== void 0) {
+      providers = providers.filter((p) => p.capabilities.supportsProcessingModes === filter.supports.processingModes);
+    }
+    if (filter.supports.segmentation !== void 0) {
+      providers = providers.filter((p) => p.capabilities.supportsSegmentation === filter.supports.segmentation);
+    }
+  }
+  if (filter.hasFeatures && filter.hasFeatures.length > 0) {
+    providers = providers.filter(
+      (p) => filter.hasFeatures.every((feature) => p.features[feature] === true)
+    );
+  }
+  if (filter.outputFormat) {
+    providers = providers.filter(
+      (p) => p.capabilities.outputFormats[filter.outputFormat] === true
+    );
+  }
+  if (filter.inputRequirements?.inputType !== void 0) {
+    const inputTypes = Array.isArray(filter.inputRequirements.inputType) ? filter.inputRequirements.inputType : [filter.inputRequirements.inputType];
+    providers = providers.filter((p) => inputTypes.includes(p.inputRequirements.inputType));
+  }
+  if (filter.compatibleWith && filter.compatibleWith.length > 0) {
+    providers = providers.filter(
+      (p) => filter.compatibleWith.every((node2) => p.compatibleNodes[node2])
+    );
+  }
+  if (filter.mimeType) {
+    const mimeTypes = Array.isArray(filter.mimeType) ? filter.mimeType : [filter.mimeType];
+    providers = providers.filter((p) => {
+      const allMimes = [...p.inputFormats.imageMimeTypes, ...p.inputFormats.documentMimeTypes];
+      return mimeTypes.every((mime) => allMimes.includes(mime));
+    });
+  }
+  if (filter.minFileSize !== void 0) {
+    providers = providers.filter((p) => {
+      const maxSize = p.inputFormats.maxFileSize ?? Math.max(p.inputFormats.maxImageSize ?? 0, p.inputFormats.maxPdfSize ?? 0);
+      return maxSize >= filter.minFileSize;
+    });
+  }
+  if (filter.maxFileSize !== void 0) {
+    providers = providers.filter((p) => {
+      const maxSize = p.inputFormats.maxFileSize ?? Math.max(p.inputFormats.maxImageSize ?? Infinity, p.inputFormats.maxPdfSize ?? Infinity);
+      return maxSize <= filter.maxFileSize;
+    });
+  }
+  if (filter.maxCostPerPage !== void 0) {
+    providers = providers.filter(
+      (p) => p.pricing.perPage !== void 0 && p.pricing.perPage <= filter.maxCostPerPage
+    );
+  }
+  if (filter.maxCostPer1kTokens !== void 0) {
+    providers = providers.filter(
+      (p) => p.pricing.inputPer1kTokens !== void 0 && p.pricing.inputPer1kTokens <= filter.maxCostPer1kTokens
+    );
+  }
+  if (filter.filter) {
+    providers = providers.filter(filter.filter);
+  }
+  return providers;
+}
+function getProviderById(id) {
+  for (const providers of providerRegistry.values()) {
+    if (providers.has(id)) {
+      return providers.get(id);
+    }
+  }
+  return void 0;
+}
+function getProvidersBySource(source) {
+  const providers = providerRegistry.get(source);
+  return providers ? [...providers.values()] : [];
+}
+function clearProviderRegistry() {
+  providerRegistry.clear();
+}
+function defaultNormalizer(id, data, source) {
+  const d = data;
+  if (source === "llm") {
+    return normalizeLLMProvider(id, d);
+  } else if (source === "datalab") {
+    return normalizeDatalabProvider(id, d);
+  } else if (source === "reducto") {
+    return normalizeReductoProvider(id, d);
+  } else if (source === "unsiloed") {
+    return normalizeUnsiloedProvider(id, d);
+  }
+  const defaultOutputFormats = { text: true, markdown: false, html: false, json: false };
+  const defaultFeatures = {
+    maxPages: false,
+    pageRange: false,
+    languageHints: false,
+    processingModes: false,
+    agenticMode: false,
+    customPrompts: false,
+    imageExtraction: false,
+    pageMarkers: false,
+    citations: false,
+    chunking: false,
+    segmentation: false,
+    stripExistingOCR: false,
+    formatLines: false,
+    forceOCR: false,
+    tableOutputFormats: false,
+    tableMerging: false,
+    confidence: false,
+    boundingBoxes: false,
+    schemaValidation: false,
+    handwrittenText: false,
+    outputFormats: defaultOutputFormats
+  };
+  return {
+    id,
+    name: d.name ?? id,
+    source,
+    type: d.type ?? "LLM",
+    capabilities: {
+      supportsImages: d.capabilities?.supportsImages ?? false,
+      supportsPDFs: d.capabilities?.supportsPDFs ?? false,
+      supportsDocuments: d.capabilities?.supportsDocuments ?? false,
+      supportsReasoning: d.capabilities?.supportsReasoning ?? false,
+      supportsStructuredOutput: d.capabilities?.supportsStructuredOutput ?? false,
+      supportsPrompts: false,
+      supportsCitations: false,
+      supportsChunking: false,
+      supportsImageExtraction: false,
+      supportsPageMarkers: false,
+      supportsLanguageHints: false,
+      supportsProcessingModes: false,
+      supportsSegmentation: false,
+      outputFormats: defaultOutputFormats
+    },
+    features: defaultFeatures,
+    inputRequirements: {
+      inputType: d.inputRequirements?.inputType ?? "any",
+      acceptedMethods: d.inputRequirements?.acceptedMethods ?? d.inputFormats?.inputMethods ?? ["base64"]
+    },
+    compatibleNodes: {
+      parse: d.compatibleNodes?.parse ?? false,
+      extract: d.compatibleNodes?.extract ?? false,
+      categorize: d.compatibleNodes?.categorize ?? false,
+      qualify: d.compatibleNodes?.qualify ?? false,
+      split: d.compatibleNodes?.split ?? false
+    },
+    inputFormats: {
+      imageMimeTypes: [],
+      documentMimeTypes: [],
+      inputMethods: ["base64"]
+    },
+    pricing: {
+      model: "per-token",
+      currency: "USD"
+    },
+    raw: data
+  };
+}
+function normalizeLLMProvider(id, d) {
+  const outputFormats = {
+    text: true,
+    markdown: true,
+    html: true,
+    json: d.capabilities?.supportsStructuredOutput ?? true
+  };
+  const features = {
+    maxPages: d.inputFormats?.pdfs?.maxPages !== void 0,
+    pageRange: true,
+    // LLMs can handle page ranges
+    languageHints: false,
+    // Not applicable to LLMs
+    processingModes: false,
+    // Not applicable to LLMs
+    agenticMode: false,
+    // Not applicable to LLMs
+    customPrompts: true,
+    // All LLMs support prompts
+    imageExtraction: false,
+    // LLMs don't extract images
+    pageMarkers: false,
+    // LLMs don't add page markers
+    citations: false,
+    // Most LLMs don't have native citations (Anthropic has different API)
+    chunking: false,
+    // LLMs don't do chunking
+    segmentation: false,
+    // LLMs don't do segmentation
+    stripExistingOCR: false,
+    formatLines: false,
+    forceOCR: false,
+    tableOutputFormats: false,
+    tableMerging: false,
+    confidence: false,
+    // LLMs don't provide confidence scores
+    boundingBoxes: false,
+    // LLMs don't provide bounding boxes
+    schemaValidation: d.capabilities?.supportsStructuredOutput ?? false,
+    // Some LLMs support schema validation
+    handwrittenText: false,
+    // Not specific to LLMs
+    outputFormats
+  };
+  const vendor = d.vendor ?? id;
+  return {
+    id,
+    name: d.name ?? id,
+    source: "llm",
+    type: "LLM",
+    // NEW: 3-layer identity
+    identity: {
+      provider: vendor,
+      model: d.defaultModel ?? id,
+      method: "native"
+    },
+    capabilities: {
+      supportsImages: d.capabilities?.supportsImages ?? false,
+      supportsPDFs: d.capabilities?.supportsPDFs ?? false,
+      supportsDocuments: false,
+      // LLM providers don't support Office docs directly
+      supportsReasoning: d.capabilities?.supportsReasoning ?? false,
+      supportsStructuredOutput: d.capabilities?.supportsStructuredOutput ?? false,
+      // NEW capabilities
+      supportsPrompts: true,
+      supportsCitations: false,
+      supportsChunking: false,
+      supportsImageExtraction: false,
+      supportsPageMarkers: false,
+      supportsLanguageHints: false,
+      supportsProcessingModes: false,
+      supportsSegmentation: false,
+      outputFormats
+    },
+    features,
+    // LLM providers with vision can work with either raw documents or parsed text
+    inputRequirements: {
+      inputType: d.inputRequirements?.inputType ?? "any",
+      acceptedMethods: d.inputRequirements?.acceptedMethods ?? d.inputFormats?.images?.methods ?? ["base64", "url"]
+    },
+    compatibleNodes: {
+      parse: d.compatibleNodes?.parse ?? false,
+      extract: d.compatibleNodes?.extract ?? false,
+      categorize: d.compatibleNodes?.categorize ?? false,
+      qualify: d.compatibleNodes?.qualify ?? false,
+      split: d.compatibleNodes?.split ?? false
+    },
+    inputFormats: {
+      imageMimeTypes: d.inputFormats?.images?.mimeTypes ?? [],
+      documentMimeTypes: ["application/pdf"],
+      // PDFs only for LLM
+      inputMethods: d.inputFormats?.images?.methods ?? ["base64"],
+      maxImageSize: d.inputFormats?.images?.maxSize,
+      maxPdfSize: d.inputFormats?.pdfs?.maxSize,
+      maxPages: d.inputFormats?.pdfs?.maxPages
+    },
+    pricing: {
+      model: "per-token",
+      inputPer1kTokens: d.pricing?.inputPer1k,
+      outputPer1kTokens: d.pricing?.outputPer1k,
+      currency: "USD",
+      notes: d.pricing?.notes
+    },
+    rateLimits: {
+      requestsPerMinute: d.limits?.requestsPerMinute
+    },
+    raw: d
+  };
+}
+function normalizeDatalabProvider(id, d) {
+  const opts = d.supportedOptions ?? {};
+  const isVLM = d.type === "VLM";
+  const model = d.model ?? id;
+  const outputFormats = {
+    text: true,
+    markdown: d.outputFormat?.features?.markdown ?? false,
+    html: false,
+    json: d.outputFormat?.features?.structuredJSON ?? isVLM
+  };
+  const features = {
+    maxPages: opts.maxPages ?? false,
+    pageRange: opts.pageRange ?? false,
+    languageHints: opts.langs ?? false,
+    // maps from 'langs'
+    processingModes: opts.mode ?? false,
+    agenticMode: false,
+    // Datalab doesn't have agentic mode
+    customPrompts: opts.blockCorrectionPrompt ?? false,
+    imageExtraction: opts.extractImages ?? false,
+    pageMarkers: opts.paginate ?? false,
+    // maps from 'paginate'
+    citations: opts.citations ?? false,
+    chunking: false,
+    // Datalab doesn't have chunking
+    segmentation: opts.segmentation ?? false,
+    stripExistingOCR: opts.stripExistingOCR ?? false,
+    formatLines: opts.formatLines ?? false,
+    forceOCR: true,
+    // Datalab supports force_ocr
+    tableOutputFormats: false,
+    tableMerging: false,
+    confidence: false,
+    // Datalab doesn't provide confidence scores
+    boundingBoxes: d.outputFormat?.features?.boundingBoxes ?? true,
+    // Datalab provides bounding boxes
+    schemaValidation: isVLM,
+    // VLM providers support schema validation
+    handwrittenText: true,
+    // Datalab handles handwritten text
+    outputFormats
+  };
+  return {
+    id,
+    name: d.name ?? id,
+    source: "datalab",
+    type: d.type ?? "OCR",
+    // NEW: 3-layer identity
+    identity: {
+      provider: "datalab",
+      model,
+      method: "native"
+      // Default to native, can be overridden when self-hosted
+    },
+    capabilities: {
+      supportsImages: d.capabilities?.supportsImages ?? true,
+      supportsPDFs: d.capabilities?.supportsPDFs ?? true,
+      supportsDocuments: d.capabilities?.supportsDocuments ?? true,
+      supportsReasoning: false,
+      // Datalab doesn't do reasoning
+      supportsStructuredOutput: isVLM,
+      // NEW capabilities from supportedOptions
+      supportsPrompts: opts.blockCorrectionPrompt ?? false,
+      supportsCitations: opts.citations ?? false,
+      supportsChunking: false,
+      supportsImageExtraction: opts.extractImages ?? false,
+      supportsPageMarkers: opts.paginate ?? false,
+      supportsLanguageHints: opts.langs ?? false,
+      supportsProcessingModes: opts.mode ?? false,
+      supportsSegmentation: opts.segmentation ?? false,
+      outputFormats
+    },
+    features,
+    // Datalab providers always need raw document input
+    inputRequirements: {
+      inputType: d.inputRequirements?.inputType ?? "raw-document",
+      acceptedMethods: d.inputRequirements?.acceptedMethods ?? d.inputFormats?.inputMethods ?? ["base64", "url"]
+    },
+    compatibleNodes: {
+      parse: d.compatibleNodes?.parse ?? false,
+      extract: d.compatibleNodes?.extract ?? false,
+      categorize: d.compatibleNodes?.categorize ?? false,
+      qualify: d.compatibleNodes?.qualify ?? false,
+      split: d.compatibleNodes?.split ?? false
+    },
+    inputFormats: {
+      imageMimeTypes: (d.inputFormats?.mimeTypes ?? []).filter((m) => m.startsWith("image/")),
+      documentMimeTypes: (d.inputFormats?.mimeTypes ?? []).filter((m) => !m.startsWith("image/")),
+      inputMethods: d.inputFormats?.inputMethods ?? ["base64"],
+      maxFileSize: d.inputFormats?.maxFileSize,
+      maxPages: d.inputFormats?.maxPages
+    },
+    pricing: {
+      model: "per-page",
+      perPage: d.pricing?.perPage,
+      currency: "USD",
+      notes: d.pricing?.notes
+    },
+    rateLimits: {
+      docsPerMinute: d.apiConfig?.rateLimit?.docsPerMinute
+    },
+    raw: d
+  };
+}
+function normalizeReductoProvider(id, d) {
+  const opts = d.supportedOptions ?? {};
+  const isVLM = d.type === "VLM";
+  const isExtract = d.compatibleNodes?.extract === true;
+  const model = d.model ?? "v1";
+  const outputFormats = {
+    text: d.outputFormat?.features?.textLines ?? true,
+    markdown: d.outputFormat?.features?.markdown ?? d.compatibleNodes?.parse ?? false,
+    html: opts.tableOutputFormat ?? false,
+    // Reducto can output HTML tables
+    json: d.outputFormat?.features?.structuredJSON ?? isExtract
+  };
+  const features = {
+    maxPages: opts.maxPages ?? false,
+    pageRange: opts.pageRange ?? false,
+    languageHints: opts.langs ?? false,
+    // Reducto doesn't support langs
+    processingModes: false,
+    // Reducto uses agentic instead
+    agenticMode: opts.mode ?? false,
+    // maps from 'mode' (agentic)
+    customPrompts: opts.additionalPrompt ?? false,
+    // maps from 'additionalPrompt'
+    imageExtraction: opts.extractImages ?? false,
+    // maps from 'returnImages'
+    pageMarkers: true,
+    // Reducto has addPageMarkers
+    citations: opts.citations ?? false,
+    chunking: opts.chunking ?? false,
+    segmentation: opts.segmentation ?? false,
+    // Via Split endpoint
+    stripExistingOCR: false,
+    formatLines: false,
+    forceOCR: false,
+    tableOutputFormats: opts.tableOutputFormat ?? false,
+    tableMerging: d.compatibleNodes?.parse ?? false,
+    // Parse has mergeTables
+    confidence: opts.confidence ?? d.outputFormat?.features?.confidence ?? false,
+    // Reducto Parse has confidence
+    boundingBoxes: d.outputFormat?.features?.boundingBoxes ?? d.compatibleNodes?.parse ?? false,
+    // Reducto Parse has bounding boxes
+    schemaValidation: d.outputFormat?.features?.schemaValidation ?? isExtract,
+    // Extract has schema validation
+    handwrittenText: false,
+    // Reducto doesn't specifically advertise handwriting
+    outputFormats
+  };
+  return {
+    id,
+    name: d.name ?? id,
+    source: "reducto",
+    type: d.type ?? "OCR",
+    // NEW: 3-layer identity
+    identity: {
+      provider: "reducto",
+      model,
+      method: "native"
+    },
+    capabilities: {
+      supportsImages: d.capabilities?.supportsImages ?? true,
+      supportsPDFs: d.capabilities?.supportsPDFs ?? true,
+      supportsDocuments: d.capabilities?.supportsDocuments ?? true,
+      supportsReasoning: false,
+      // Reducto doesn't do reasoning
+      supportsStructuredOutput: isVLM || isExtract,
+      // NEW capabilities from supportedOptions
+      supportsPrompts: opts.additionalPrompt ?? false,
+      supportsCitations: opts.citations ?? false,
+      supportsChunking: opts.chunking ?? false,
+      supportsImageExtraction: opts.extractImages ?? false,
+      supportsPageMarkers: true,
+      supportsLanguageHints: false,
+      supportsProcessingModes: opts.mode ?? false,
+      // agentic mode
+      supportsSegmentation: opts.segmentation ?? false,
+      outputFormats
+    },
+    features,
+    // Reducto providers always need raw document input
+    inputRequirements: {
+      inputType: d.inputRequirements?.inputType ?? "raw-document",
+      acceptedMethods: d.inputRequirements?.acceptedMethods ?? d.inputFormats?.inputMethods ?? ["base64", "url"]
+    },
+    compatibleNodes: {
+      parse: d.compatibleNodes?.parse ?? false,
+      extract: d.compatibleNodes?.extract ?? false,
+      categorize: d.compatibleNodes?.categorize ?? false,
+      qualify: d.compatibleNodes?.qualify ?? false,
+      split: d.compatibleNodes?.split ?? false
+    },
+    inputFormats: {
+      imageMimeTypes: (d.inputFormats?.mimeTypes ?? []).filter((m) => m.startsWith("image/")),
+      documentMimeTypes: (d.inputFormats?.mimeTypes ?? []).filter((m) => !m.startsWith("image/")),
+      inputMethods: d.inputFormats?.inputMethods ?? ["base64"],
+      maxFileSize: d.inputFormats?.maxFileSize,
+      maxPages: d.inputFormats?.maxPages
+    },
+    pricing: {
+      model: "per-page",
+      perPage: d.pricing?.standard ? d.pricing.standard * (d.pricing.usdPerCredit ?? 4e-3) : d.pricing?.perPage,
+      currency: "USD",
+      notes: d.pricing?.notes
+    },
+    rateLimits: {
+      docsPerMinute: d.apiConfig?.rateLimit?.docsPerMinute
+    },
+    raw: d
+  };
+}
+function normalizeUnsiloedProvider(id, d) {
+  const isVLM = d.type === "VLM";
+  const isExtract = d.compatibleNodes?.extract === true;
+  const isParse = d.compatibleNodes?.parse === true;
+  const isSplit = d.compatibleNodes?.split === true;
+  const isCategorize = d.compatibleNodes?.categorize === true;
+  const model = d.model ?? "v1";
+  const outputFormats = {
+    text: d.outputFormat?.features?.textLines ?? isParse,
+    markdown: d.outputFormat?.features?.markdown ?? isParse,
+    html: false,
+    // Unsiloed doesn't output HTML
+    json: d.outputFormat?.features?.structuredJSON ?? (isVLM || isExtract)
+  };
+  const features = {
+    maxPages: false,
+    // Unsiloed doesn't have max pages option
+    pageRange: false,
+    // Unsiloed doesn't have page range option
+    languageHints: false,
+    // Unsiloed doesn't support language hints
+    processingModes: d.capabilities?.specialFeatures?.includes("YOLO segmentation") ?? false,
+    agenticMode: false,
+    // Unsiloed doesn't have agentic mode
+    customPrompts: false,
+    // Unsiloed doesn't support custom prompts
+    imageExtraction: false,
+    // Unsiloed doesn't extract images
+    pageMarkers: false,
+    // Unsiloed doesn't add page markers
+    citations: d.outputFormat?.features?.citations ?? isExtract,
+    // Extract has citations
+    chunking: d.outputFormat?.features?.semanticChunking ?? isParse,
+    // Parse has semantic chunking
+    segmentation: isSplit,
+    // Split provider does segmentation
+    stripExistingOCR: false,
+    formatLines: false,
+    forceOCR: false,
+    tableOutputFormats: false,
+    tableMerging: false,
+    confidence: d.outputFormat?.features?.confidence ?? false,
+    // Unsiloed may provide confidence
+    boundingBoxes: d.outputFormat?.features?.boundingBoxes ?? false,
+    // Unsiloed may provide bounding boxes
+    schemaValidation: isExtract,
+    // Extract supports schema validation
+    handwrittenText: false,
+    // Unsiloed doesn't specifically advertise handwriting
+    outputFormats
+  };
+  return {
+    id,
+    name: d.name ?? id,
+    source: "unsiloed",
+    type: d.type ?? "OCR",
+    // NEW: 3-layer identity
+    identity: {
+      provider: "unsiloed",
+      model,
+      method: "native"
+    },
+    capabilities: {
+      supportsImages: d.capabilities?.supportsImages ?? true,
+      supportsPDFs: d.capabilities?.supportsPDFs ?? true,
+      supportsDocuments: d.capabilities?.supportsDocuments ?? false,
+      supportsReasoning: false,
+      // Unsiloed doesn't do reasoning
+      supportsStructuredOutput: isVLM || isExtract,
+      // NEW capabilities
+      supportsPrompts: false,
+      // Unsiloed doesn't support custom prompts
+      supportsCitations: d.outputFormat?.features?.citations ?? isExtract,
+      supportsChunking: d.outputFormat?.features?.semanticChunking ?? isParse,
+      supportsImageExtraction: false,
+      supportsPageMarkers: false,
+      supportsLanguageHints: false,
+      supportsProcessingModes: d.capabilities?.specialFeatures?.includes("YOLO segmentation") ?? false,
+      supportsSegmentation: isSplit || isCategorize,
+      outputFormats
+    },
+    features,
+    // Unsiloed providers always need raw document input
+    inputRequirements: {
+      inputType: d.inputRequirements?.inputType ?? "raw-document",
+      acceptedMethods: d.inputRequirements?.acceptedMethods ?? d.inputFormats?.inputMethods ?? ["base64", "url"]
+    },
+    compatibleNodes: {
+      parse: d.compatibleNodes?.parse ?? false,
+      extract: d.compatibleNodes?.extract ?? false,
+      categorize: d.compatibleNodes?.categorize ?? false,
+      qualify: d.compatibleNodes?.qualify ?? false,
+      split: d.compatibleNodes?.split ?? false
+    },
+    inputFormats: {
+      imageMimeTypes: (d.inputFormats?.mimeTypes ?? []).filter((m) => m.startsWith("image/")),
+      documentMimeTypes: (d.inputFormats?.mimeTypes ?? []).filter((m) => !m.startsWith("image/")),
+      inputMethods: d.inputFormats?.inputMethods ?? ["base64"],
+      maxFileSize: d.inputFormats?.maxFileSize,
+      maxPages: d.inputFormats?.maxPages
+    },
+    pricing: {
+      model: "per-page",
+      perPage: d.pricing?.standardUSD ?? d.pricing?.perPage,
+      currency: "USD",
+      notes: d.pricing?.notes
+    },
+    rateLimits: {
+      docsPerMinute: d.apiConfig?.rateLimit?.docsPerMinute
+    },
+    raw: d
+  };
+}
+function getProvidersForMimeType(mimeType) {
+  return queryProviders({ mimeType });
+}
+function getCheapestProviderFor(capability) {
+  let providers;
+  switch (capability) {
+    case "ocr":
+    case "parse":
+      providers = queryProviders({ compatibleWith: ["parse"] });
+      break;
+    case "extraction":
+      providers = queryProviders({ compatibleWith: ["extract"] });
+      break;
+  }
+  return providers.sort((a, b) => {
+    const costA = a.pricing.perPage ?? (a.pricing.inputPer1kTokens ?? Infinity);
+    const costB = b.pricing.perPage ?? (b.pricing.inputPer1kTokens ?? Infinity);
+    return costA - costB;
+  })[0];
+}
+function getProvidersForLargeFiles(minSizeMB = 100) {
+  return queryProviders({ minFileSize: minSizeMB });
+}
+var modelRegistry = /* @__PURE__ */ new Map();
+function registerProviderWithModels(providerId, metadata) {
+  modelRegistry.set(providerId, metadata);
+}
+function resolveModelMetadata(providerId, modelId) {
+  const providerWithModels = modelRegistry.get(providerId);
+  if (providerWithModels) {
+    return resolveFromProviderWithModels(providerWithModels, modelId);
+  }
+  const provider = getProviderById(providerId);
+  if (!provider) return void 0;
+  return {
+    modelId: modelId ?? providerId,
+    modelName: modelId ?? provider.name,
+    providerId: provider.id,
+    providerName: provider.name,
+    providerSource: provider.source,
+    capabilities: { ...provider.capabilities },
+    features: { ...provider.features },
+    inputRequirements: { ...provider.inputRequirements },
+    compatibleNodes: { ...provider.compatibleNodes },
+    pricing: { ...provider.pricing }
+  };
+}
+function resolveFromProviderWithModels(provider, modelId) {
+  const model = modelId ? provider.models?.find((m) => m.id === modelId) : void 0;
+  return {
+    modelId: model?.id ?? modelId ?? provider.id,
+    modelName: model?.name ?? model?.id ?? modelId ?? provider.name,
+    openRouterId: model?.openRouterId,
+    providerId: provider.id,
+    providerName: provider.name,
+    providerSource: provider.source,
+    // Merge capabilities (model overrides provider)
+    capabilities: {
+      supportsImages: model?.capabilities?.supportsImages ?? provider.capabilities.supportsImages,
+      supportsPDFs: model?.capabilities?.supportsPDFs ?? provider.capabilities.supportsPDFs,
+      supportsDocuments: model?.capabilities?.supportsDocuments ?? provider.capabilities.supportsDocuments,
+      supportsReasoning: model?.capabilities?.supportsReasoning ?? provider.capabilities.supportsReasoning,
+      supportsStructuredOutput: model?.capabilities?.supportsStructuredOutput ?? provider.capabilities.supportsStructuredOutput,
+      // NEW capabilities
+      supportsPrompts: model?.capabilities?.supportsPrompts ?? provider.capabilities.supportsPrompts,
+      supportsCitations: model?.capabilities?.supportsCitations ?? provider.capabilities.supportsCitations,
+      supportsChunking: model?.capabilities?.supportsChunking ?? provider.capabilities.supportsChunking,
+      supportsImageExtraction: model?.capabilities?.supportsImageExtraction ?? provider.capabilities.supportsImageExtraction,
+      supportsPageMarkers: model?.capabilities?.supportsPageMarkers ?? provider.capabilities.supportsPageMarkers,
+      supportsLanguageHints: model?.capabilities?.supportsLanguageHints ?? provider.capabilities.supportsLanguageHints,
+      supportsProcessingModes: model?.capabilities?.supportsProcessingModes ?? provider.capabilities.supportsProcessingModes,
+      supportsSegmentation: model?.capabilities?.supportsSegmentation ?? provider.capabilities.supportsSegmentation,
+      outputFormats: model?.capabilities?.outputFormats ?? provider.capabilities.outputFormats
+    },
+    // Merge input requirements
+    inputRequirements: {
+      inputType: model?.inputRequirements?.inputType ?? provider.inputRequirements.inputType,
+      acceptedMethods: model?.inputRequirements?.acceptedMethods ?? provider.inputRequirements.acceptedMethods
+    },
+    // Merge node compatibility
+    compatibleNodes: {
+      parse: model?.compatibleNodes?.parse ?? provider.compatibleNodes.parse,
+      extract: model?.compatibleNodes?.extract ?? provider.compatibleNodes.extract,
+      categorize: model?.compatibleNodes?.categorize ?? provider.compatibleNodes.categorize,
+      qualify: model?.compatibleNodes?.qualify ?? provider.compatibleNodes.qualify,
+      split: model?.compatibleNodes?.split ?? provider.compatibleNodes.split
+    },
+    // Features (inherited from provider - models don't override features)
+    features: { ...provider.features },
+    // Merge pricing
+    pricing: {
+      model: provider.pricing.model,
+      inputPer1kTokens: model?.pricing?.inputPer1kTokens ?? provider.pricing.inputPer1kTokens,
+      outputPer1kTokens: model?.pricing?.outputPer1kTokens ?? provider.pricing.outputPer1kTokens,
+      perPage: model?.pricing?.perPage ?? provider.pricing.perPage,
+      currency: provider.pricing.currency,
+      notes: provider.pricing.notes
+    },
+    // Model limits
+    limits: model?.limits
+  };
+}
+function queryModels(filter = {}) {
+  const results = [];
+  for (const [providerId, provider] of modelRegistry) {
+    if (filter.providerId) {
+      const providerIds = Array.isArray(filter.providerId) ? filter.providerId : [filter.providerId];
+      if (!providerIds.includes(providerId)) continue;
+    }
+    if (filter.source) {
+      const sources = Array.isArray(filter.source) ? filter.source : [filter.source];
+      if (!sources.includes(provider.source)) continue;
+    }
+    const models = provider.models ?? [{ id: provider.id }];
+    for (const model of models) {
+      const resolved = resolveFromProviderWithModels(provider, model.id);
+      if (matchesModelFilter(resolved, filter)) {
+        results.push(resolved);
+      }
+    }
+  }
+  for (const provider of getAllProviders()) {
+    if (modelRegistry.has(provider.id)) continue;
+    if (filter.providerId) {
+      const providerIds = Array.isArray(filter.providerId) ? filter.providerId : [filter.providerId];
+      if (!providerIds.includes(provider.id)) continue;
+    }
+    if (filter.source) {
+      const sources = Array.isArray(filter.source) ? filter.source : [filter.source];
+      if (!sources.includes(provider.source)) continue;
+    }
+    const resolved = resolveModelMetadata(provider.id);
+    if (resolved && matchesModelFilter(resolved, filter)) {
+      results.push(resolved);
+    }
+  }
+  return results;
+}
+function matchesModelFilter(model, filter) {
+  if (filter.supports) {
+    if (filter.supports.images !== void 0 && model.capabilities.supportsImages !== filter.supports.images) {
+      return false;
+    }
+    if (filter.supports.pdfs !== void 0 && model.capabilities.supportsPDFs !== filter.supports.pdfs) {
+      return false;
+    }
+    if (filter.supports.documents !== void 0 && model.capabilities.supportsDocuments !== filter.supports.documents) {
+      return false;
+    }
+    if (filter.supports.reasoning !== void 0 && model.capabilities.supportsReasoning !== filter.supports.reasoning) {
+      return false;
+    }
+    if (filter.supports.structuredOutput !== void 0 && model.capabilities.supportsStructuredOutput !== filter.supports.structuredOutput) {
+      return false;
+    }
+    if (filter.supports.prompts !== void 0 && model.capabilities.supportsPrompts !== filter.supports.prompts) {
+      return false;
+    }
+    if (filter.supports.citations !== void 0 && model.capabilities.supportsCitations !== filter.supports.citations) {
+      return false;
+    }
+    if (filter.supports.chunking !== void 0 && model.capabilities.supportsChunking !== filter.supports.chunking) {
+      return false;
+    }
+    if (filter.supports.imageExtraction !== void 0 && model.capabilities.supportsImageExtraction !== filter.supports.imageExtraction) {
+      return false;
+    }
+    if (filter.supports.pageMarkers !== void 0 && model.capabilities.supportsPageMarkers !== filter.supports.pageMarkers) {
+      return false;
+    }
+    if (filter.supports.languageHints !== void 0 && model.capabilities.supportsLanguageHints !== filter.supports.languageHints) {
+      return false;
+    }
+    if (filter.supports.processingModes !== void 0 && model.capabilities.supportsProcessingModes !== filter.supports.processingModes) {
+      return false;
+    }
+    if (filter.supports.segmentation !== void 0 && model.capabilities.supportsSegmentation !== filter.supports.segmentation) {
+      return false;
+    }
+  }
+  if (filter.hasFeatures && filter.hasFeatures.length > 0) {
+    for (const feature of filter.hasFeatures) {
+      if (model.features[feature] !== true) {
+        return false;
+      }
+    }
+  }
+  if (filter.outputFormat) {
+    if (model.capabilities.outputFormats[filter.outputFormat] !== true) {
+      return false;
+    }
+  }
+  if (filter.inputRequirements?.inputType !== void 0) {
+    const inputTypes = Array.isArray(filter.inputRequirements.inputType) ? filter.inputRequirements.inputType : [filter.inputRequirements.inputType];
+    if (!inputTypes.includes(model.inputRequirements.inputType)) {
+      return false;
+    }
+  }
+  if (filter.compatibleWith && filter.compatibleWith.length > 0) {
+    for (const node2 of filter.compatibleWith) {
+      if (!model.compatibleNodes[node2]) {
+        return false;
+      }
+    }
+  }
+  if (filter.minContextTokens !== void 0) {
+    const contextTokens = model.limits?.maxContextTokens ?? 0;
+    if (contextTokens < filter.minContextTokens) {
+      return false;
+    }
+  }
+  if (filter.filter && !filter.filter(model)) {
+    return false;
+  }
+  return true;
+}
+function getModelsForNode(nodeType) {
+  return queryModels({ compatibleWith: [nodeType] });
+}
+function getAllModels() {
+  return queryModels({});
+}
+function clearModelRegistry() {
+  modelRegistry.clear();
+}
+export {
+  FlowExecutionError,
+  FlowInputValidationError,
+  FlowValidationError,
+  NODE_COMPATIBILITY_MATRIX,
+  RESERVED_VARIABLES,
+  aggregateMetrics,
+  bufferToBase64,
+  bufferToDataUri,
+  buildProviderFromConfig,
+  buildProvidersFromConfigs,
+  canStartForEachItemFlow,
+  clearModelRegistry,
+  clearProviderRegistry,
+  createIdentity,
+  defineMarkerProvider,
+  defineSuryaProvider,
+  defineVLMProvider,
+  detectDocumentType,
+  detectMimeTypeFromBase64,
+  detectMimeTypeFromBase64Async,
+  detectMimeTypeFromBytes,
+  extractBase64,
+  getAllModels,
+  getAllProviders,
+  getCheapestProviderFor,
+  getCompatibleTargets,
+  getDocumentPageCount,
+  getModelsForNode,
+  getNodeTypeInfo,
+  getNodeTypeName,
+  getPDFPageCount,
+  getPageCountMetadata,
+  getProviderById,
+  getProvidersBySource,
+  getProvidersForLargeFiles,
+  getProvidersForMimeType,
+  getSuggestedConnections,
+  getTotalPageCount,
+  getValidForEachStarters,
+  isLocalEndpoint,
+  isPDFDocument,
+  node,
+  parseProviderString,
+  protectReservedVariables,
+  queryModels,
+  queryProviders,
+  registerProviderMetadata,
+  registerProviderWithModels,
+  resolveDocument,
+  resolveModelMetadata,
+  runPipeline,
+  splitPDFIntoChunks,
+  toProviderString,
+  validateFlowInputFormat,
+  validateJson,
+  validateMimeType,
+  validateMimeTypeAsync,
+  validateNodeConnection
+};
+//# sourceMappingURL=index.js.map