@doclo/providers-llm 0.1.5

package/dist/index.js

@@ -0,0 +1,2743 @@
+// src/schema-translator.ts
+import { zodToJsonSchema } from "@alcyone-labs/zod-to-json-schema";
+var SchemaTranslator = class {
+  /**
+   * Unified → OpenAI/Grok (standard JSON Schema)
+   * OpenAI strict mode doesn't support nullable: true
+   * Must convert to anyOf: [{ type: "string" }, { type: "null" }]
+   */
+  toOpenAISchema(schema) {
+    const jsonSchema = this.convertZodIfNeeded(schema);
+    return this.convertNullableToAnyOf(jsonSchema);
+  }
+  /**
+   * Detect if schema is a Zod schema and convert to JSON Schema
+   * Public method to allow embedding schemas in prompts
+   */
+  convertZodIfNeeded(schema) {
+    if (schema && typeof schema === "object") {
+      const flexibleSchema = schema;
+      if (flexibleSchema["~standard"]?.vendor === "zod") {
+        const jsonSchema = zodToJsonSchema(schema);
+        delete jsonSchema.$schema;
+        delete jsonSchema.$defs;
+        delete jsonSchema.definitions;
+        return jsonSchema;
+      }
+      if (flexibleSchema._def) {
+        const jsonSchema = zodToJsonSchema(schema);
+        delete jsonSchema.$schema;
+        delete jsonSchema.$defs;
+        delete jsonSchema.definitions;
+        return jsonSchema;
+      }
+    }
+    return schema;
+  }
+  /**
+   * Convert nullable fields to anyOf format for OpenAI strict mode
+   * nullable: true is not supported, must use anyOf with null type
+   */
+  convertNullableToAnyOf(schema) {
+    if (typeof schema !== "object" || schema === null) {
+      return schema;
+    }
+    const result = { ...schema };
+    if (result.nullable === true) {
+      delete result.nullable;
+      const baseType = result.type;
+      if (baseType) {
+        return {
+          anyOf: [
+            { type: baseType },
+            { type: "null" }
+          ]
+        };
+      }
+    }
+    if (result.properties) {
+      result.properties = Object.fromEntries(
+        Object.entries(result.properties).map(([key, value]) => {
+          if (value && typeof value === "object" && value.nullable === true) {
+            const { nullable, type, ...rest } = value;
+            return [key, {
+              anyOf: [
+                { type, ...rest },
+                { type: "null" }
+              ]
+            }];
+          }
+          return [key, this.convertNullableToAnyOf(value)];
+        })
+      );
+    }
+    if (result.items && !Array.isArray(result.items)) {
+      result.items = this.convertNullableToAnyOf(result.items);
+    }
+    const keywords = ["anyOf", "oneOf", "allOf"];
+    keywords.forEach((keyword) => {
+      const schemaArray = result[keyword];
+      if (schemaArray && Array.isArray(schemaArray)) {
+        result[keyword] = schemaArray.map((s) => this.convertNullableToAnyOf(s));
+      }
+    });
+    return result;
+  }
+  /**
+   * Unified → Claude (Tool Input Schema format)
+   * Claude requires tool calling with input_schema
+   * Claude supports nullable: true directly
+   */
+  toClaudeToolSchema(schema) {
+    const jsonSchema = this.convertZodIfNeeded(schema);
+    return {
+      name: "extract_data",
+      description: "Extract structured data according to the schema",
+      input_schema: jsonSchema
+    };
+  }
+  /**
+   * Unified → Claude for OpenRouter
+   * When using Claude via OpenRouter, use anyOf format like OpenAI
+   */
+  toClaudeOpenRouterSchema(schema) {
+    const jsonSchema = this.convertZodIfNeeded(schema);
+    return this.convertNullableToAnyOf(jsonSchema);
+  }
+  /**
+   * Unified → Gemini (OpenAPI 3.0 subset with propertyOrdering)
+   * Gemini uses a subset of OpenAPI 3.0 schema
+   */
+  toGeminiSchema(schema) {
+    const jsonSchema = this.convertZodIfNeeded(schema);
+    const geminiSchema = {
+      type: jsonSchema.type
+    };
+    if (jsonSchema.properties) {
+      geminiSchema.properties = {};
+      const propertyNames = Object.keys(jsonSchema.properties);
+      geminiSchema.propertyOrdering = propertyNames;
+      for (const [key, value] of Object.entries(jsonSchema.properties)) {
+        geminiSchema.properties[key] = this.convertPropertyToGemini(value);
+      }
+    }
+    if (jsonSchema.required && Array.isArray(jsonSchema.required)) {
+      geminiSchema.required = jsonSchema.required;
+    }
+    if (jsonSchema.additionalProperties !== void 0) {
+      geminiSchema.additionalProperties = jsonSchema.additionalProperties;
+    }
+    return geminiSchema;
+  }
+  /**
+   * Convert individual property to Gemini format
+   */
+  convertPropertyToGemini(property) {
+    const geminiProp = {
+      type: property.type
+    };
+    if (property.description) {
+      geminiProp.description = property.description;
+    }
+    if (property.nullable !== void 0) {
+      geminiProp.nullable = property.nullable;
+    }
+    if (property.enum) {
+      geminiProp.enum = property.enum;
+    }
+    if (property.items) {
+      if (Array.isArray(property.items)) {
+        geminiProp.items = property.items.length > 0 ? this.convertPropertyToGemini(property.items[0]) : void 0;
+      } else {
+        geminiProp.items = this.convertPropertyToGemini(property.items);
+      }
+    }
+    if (property.properties) {
+      geminiProp.properties = {};
+      for (const [key, value] of Object.entries(property.properties)) {
+        geminiProp.properties[key] = this.convertPropertyToGemini(value);
+      }
+    }
+    if (property.required) {
+      geminiProp.required = property.required;
+    }
+    return geminiProp;
+  }
+};
+
+// src/schema-prompt-formatter.ts
+function formatSchemaForPrompt(schema, indent = 0) {
+  if (!schema || typeof schema !== "object") {
+    return "";
+  }
+  const indentStr = "  ".repeat(indent);
+  let result = "";
+  if (schema.type === "object" && schema.properties) {
+    const properties = schema.properties;
+    const required = schema.required || [];
+    for (const [fieldName, fieldSchema] of Object.entries(properties)) {
+      const isRequired = required.includes(fieldName);
+      const requiredMarker = isRequired ? " (REQUIRED)" : " (optional)";
+      result += `${indentStr}- \`${fieldName}\`${requiredMarker}`;
+      const type = getTypeDescription(fieldSchema);
+      if (type) {
+        result += `: ${type}`;
+      }
+      if (fieldSchema.description) {
+        result += `
+${indentStr}  ${fieldSchema.description}`;
+      }
+      if (fieldSchema.enum) {
+        result += `
+${indentStr}  Allowed values: ${fieldSchema.enum.map((v) => JSON.stringify(v)).join(", ")}`;
+      }
+      result += "\n";
+      if (fieldSchema.type === "object" && fieldSchema.properties) {
+        result += formatSchemaForPrompt(fieldSchema, indent + 1);
+      }
+      if (fieldSchema.type === "array" && fieldSchema.items) {
+        result += `${indentStr}  Array items:
+`;
+        const itemSchema = Array.isArray(fieldSchema.items) ? fieldSchema.items[0] : fieldSchema.items;
+        if (itemSchema && itemSchema.type === "object" && itemSchema.properties) {
+          result += formatSchemaForPrompt(itemSchema, indent + 2);
+        } else if (itemSchema) {
+          const itemType = getTypeDescription(itemSchema);
+          result += `${indentStr}    ${itemType}
+`;
+        }
+      }
+    }
+  }
+  return result;
+}
+function getTypeDescription(schema) {
+  if (!schema) return "any";
+  if (schema.type) {
+    const typeStr = Array.isArray(schema.type) ? schema.type.join(" | ") : schema.type;
+    if (typeStr === "array" || Array.isArray(schema.type) && schema.type.includes("array")) {
+      if (schema.items && !Array.isArray(schema.items) && schema.items.type) {
+        const itemType = Array.isArray(schema.items.type) ? schema.items.type.join(" | ") : schema.items.type;
+        return `array of ${itemType}`;
+      }
+      return "array";
+    }
+    if ((typeStr === "string" || Array.isArray(schema.type) && schema.type.includes("string")) && schema.format) {
+      const formatHints = {
+        "date": "YYYY-MM-DD",
+        "time": "HH:MM or HH:MM:SS",
+        "date-time": "YYYY-MM-DDTHH:MM:SS (ISO 8601)"
+      };
+      const hint = formatHints[schema.format];
+      if (hint) {
+        return `string (format: ${schema.format}, use ${hint})`;
+      }
+      return `string (format: ${schema.format})`;
+    }
+    return typeStr;
+  }
+  if (schema.anyOf) {
+    return schema.anyOf.map((s) => getTypeDescription(s)).join(" OR ");
+  }
+  if (schema.oneOf) {
+    return schema.oneOf.map((s) => getTypeDescription(s)).join(" OR ");
+  }
+  return "any";
+}
+function buildSchemaPromptSection(schema) {
+  const schemaFields = formatSchemaForPrompt(schema);
+  return `
+==================================================
+CRITICAL: OUTPUT STRUCTURE REQUIREMENTS
+==================================================
+
+YOU MUST RETURN JSON MATCHING THIS EXACT STRUCTURE:
+
+${schemaFields}
+
+CRITICAL FIELD NAME REQUIREMENTS:
+\u2713 Use EXACTLY the field names shown above (character-for-character match)
+\u2713 Preserve the exact casing (e.g., "fullName", not "full_name" or "FullName")
+\u2713 Do NOT abbreviate field names (e.g., "dob" instead of "dateOfBirth")
+\u2713 Do NOT invent alternative names (e.g., "directorName" instead of "fullName")
+\u2713 Do NOT use snake_case if the schema uses camelCase
+\u2713 Do NOT flatten nested structures or rename nested fields
+\u2713 The schema above is the SINGLE SOURCE OF TRUTH for field naming
+
+MISSING DATA:
+- If a required field has no data in the document, use null
+- If an optional field has no data, you may omit it or use null
+- Do NOT invent data that isn't in the document
+
+==================================================
+`.trim();
+}
+function combineSchemaAndUserPrompt(schema, userPrompt) {
+  const schemaSection = buildSchemaPromptSection(schema);
+  if (!userPrompt || userPrompt.trim() === "") {
+    return schemaSection + "\n\nTASK: Extract structured data from the provided document.";
+  }
+  return schemaSection + "\n\n" + userPrompt;
+}
+
+// src/provider-registry.ts
+function normalizeProviderType(type) {
+  if (type === "x-ai") return "xai";
+  return type;
+}
+var ProviderRegistry = class {
+  factories = /* @__PURE__ */ new Map();
+  /**
+   * Register a provider factory
+   * Called by each provider package when it's imported
+   */
+  register(type, factory) {
+    const normalizedType = normalizeProviderType(type);
+    this.factories.set(normalizedType, factory);
+  }
+  /**
+   * Check if a provider is registered
+   */
+  has(type) {
+    const normalizedType = normalizeProviderType(type);
+    return this.factories.has(normalizedType);
+  }
+  /**
+   * Get a provider factory
+   */
+  get(type) {
+    const normalizedType = normalizeProviderType(type);
+    return this.factories.get(normalizedType);
+  }
+  /**
+   * Create a provider instance
+   * @throws Error if provider is not registered
+   */
+  create(config) {
+    const normalizedType = normalizeProviderType(config.provider);
+    const factory = this.factories.get(normalizedType);
+    if (!factory) {
+      const registered = Array.from(this.factories.keys()).join(", ") || "none";
+      throw new Error(
+        `Provider '${config.provider}' is not registered. Registered providers: ${registered}. Make sure to import the provider package (e.g., import '@doclo/providers-${normalizedType}').`
+      );
+    }
+    return factory({ ...config, provider: normalizedType });
+  }
+  /**
+   * Get all registered provider types
+   */
+  getRegisteredTypes() {
+    return Array.from(this.factories.keys());
+  }
+  /**
+   * Clear all registrations (for testing)
+   */
+  clear() {
+    this.factories.clear();
+  }
+};
+var providerRegistry = new ProviderRegistry();
+function registerProvider(type, factory) {
+  providerRegistry.register(type, factory);
+}
+function createProviderFromRegistry(config) {
+  return providerRegistry.create(config);
+}
+
+// src/providers/openai.ts
+import { fetchWithTimeout, DEFAULT_LIMITS, safeJsonParse } from "@doclo/core/security";
+function extractProviderFromModel(model, defaultProvider) {
+  const slashIndex = model.indexOf("/");
+  return slashIndex > 0 ? model.substring(0, slashIndex) : defaultProvider;
+}
+var OpenAIProvider = class {
+  name;
+  capabilities = {
+    supportsStructuredOutput: true,
+    supportsStreaming: true,
+    supportsImages: true,
+    supportsPDFs: true,
+    maxPDFPages: 100,
+    maxPDFSize: 32,
+    maxContextTokens: 128e3
+  };
+  config;
+  translator;
+  limits;
+  constructor(config) {
+    this.config = config;
+    const baseProvider = extractProviderFromModel(config.model, "openai");
+    this.name = `${baseProvider}:${config.model}`;
+    this.translator = new SchemaTranslator();
+    this.limits = {
+      ...DEFAULT_LIMITS,
+      ...config.limits || {}
+    };
+  }
+  async completeJson(params) {
+    const startTime = Date.now();
+    const mode = params.mode || (params.schema ? "strict" : "relaxed");
+    if (mode === "strict" && !params.schema) {
+      throw new Error('schema is required when mode is "strict"');
+    }
+    const shouldEmbedSchema = params.embedSchemaInPrompt !== false && params.schema;
+    let enhancedInput = params.input;
+    if (shouldEmbedSchema) {
+      const jsonSchema = this.translator.convertZodIfNeeded(params.schema);
+      const enhancedText = combineSchemaAndUserPrompt(
+        jsonSchema,
+        params.input.text || ""
+      );
+      enhancedInput = {
+        ...params.input,
+        text: enhancedText
+      };
+    }
+    const messages = this.buildMessages(enhancedInput);
+    const requestBody = {
+      model: this.config.model,
+      messages,
+      max_tokens: params.max_tokens || 4096,
+      // Set reasonable default to avoid massive token requests
+      // Enable usage tracking for OpenRouter cost info
+      usage: {
+        include: true
+      }
+    };
+    if (mode === "relaxed") {
+      requestBody.response_format = {
+        type: "json_object"
+      };
+      if (process.env.DEBUG_PROVIDERS) {
+        console.log("[OpenAIProvider] Using relaxed JSON mode (json_object)");
+      }
+    } else {
+      const schema = this.translator.toOpenAISchema(params.schema);
+      const fixSchemaForAzure = (obj) => {
+        if (obj && typeof obj === "object") {
+          if (obj.type === "object" && obj.properties) {
+            const allProps = Object.keys(obj.properties);
+            obj.required = allProps;
+            obj.additionalProperties = false;
+            for (const key in obj.properties) {
+              obj.properties[key] = fixSchemaForAzure(obj.properties[key]);
+            }
+          } else if (obj.type === "array" && obj.items) {
+            obj.items = fixSchemaForAzure(obj.items);
+          }
+        }
+        return obj;
+      };
+      fixSchemaForAzure(schema);
+      if (process.env.DEBUG_PROVIDERS) {
+        console.log("[OpenAIProvider] Using strict JSON mode (json_schema)");
+        console.log("[OpenAIProvider] Fixed schema:", JSON.stringify(schema, null, 2));
+      }
+      requestBody.response_format = {
+        type: "json_schema",
+        json_schema: {
+          name: "extraction",
+          strict: true,
+          schema
+        }
+      };
+    }
+    if (params.reasoning) {
+      requestBody.reasoning = this.buildReasoningConfig(params.reasoning);
+    }
+    if (this.config.via === "openrouter" && mode === "strict") {
+      requestBody.provider = {
+        require_parameters: true
+        // Only route to models supporting json_schema
+      };
+    }
+    const endpoint = this.config.via === "openrouter" ? "https://openrouter.ai/api/v1" : this.config.baseUrl || "https://api.openai.com/v1";
+    const headers = {
+      "Content-Type": "application/json",
+      "Authorization": `Bearer ${this.config.apiKey}`
+    };
+    if (this.config.via === "openrouter") {
+      headers["HTTP-Referer"] = "https://github.com/docloai/sdk";
+      headers["X-Title"] = "Doclo SDK";
+    }
+    const response = await fetchWithTimeout(`${endpoint}/chat/completions`, {
+      method: "POST",
+      headers,
+      body: JSON.stringify(requestBody)
+    }, this.limits.REQUEST_TIMEOUT);
+    if (!response.ok) {
+      const error = await response.text();
+      throw new Error(`OpenAI API error (${response.status}): ${error}`);
+    }
+    const data = await response.json();
+    const latencyMs = Date.now() - startTime;
+    const content = data.choices?.[0]?.message?.content ?? "{}";
+    const parsed = safeJsonParse(content);
+    const message = data.choices?.[0]?.message;
+    const reasoning = message?.reasoning;
+    const reasoning_details = message?.reasoning_details;
+    let costUSD;
+    if (this.config.via === "openrouter") {
+      costUSD = data.usage?.total_cost ?? data.usage?.cost;
+    } else {
+      costUSD = this.calculateCost(data.usage);
+    }
+    const baseProvider = extractProviderFromModel(this.config.model, "openai");
+    return {
+      json: parsed,
+      rawText: content,
+      metrics: {
+        costUSD,
+        inputTokens: data.usage?.prompt_tokens,
+        outputTokens: data.usage?.completion_tokens,
+        latencyMs,
+        attemptNumber: 1,
+        provider: baseProvider,
+        // Base provider (e.g., "openai" from "openai/gpt-4...")
+        model: this.config.model
+      },
+      reasoning,
+      reasoning_details
+    };
+  }
+  buildReasoningConfig(reasoning) {
+    const config = {};
+    if (reasoning.effort) {
+      config.effort = reasoning.effort;
+    } else if (reasoning.enabled) {
+      config.effort = "medium";
+    }
+    if (reasoning.exclude !== void 0) {
+      config.exclude = reasoning.exclude;
+    }
+    return Object.keys(config).length > 0 ? config : void 0;
+  }
+  buildMessages(input) {
+    const content = [];
+    if (input.text) {
+      content.push({ type: "text", text: input.text });
+    }
+    if (input.images && input.images.length > 0) {
+      for (const image of input.images) {
+        if (image.url) {
+          content.push({
+            type: "image_url",
+            image_url: { url: image.url }
+          });
+        } else if (image.base64) {
+          content.push({
+            type: "image_url",
+            image_url: {
+              url: `data:${image.mimeType};base64,${this.extractBase64(image.base64)}`
+            }
+          });
+        }
+      }
+    }
+    if (input.pdfs && input.pdfs.length > 0) {
+      for (const pdf of input.pdfs) {
+        let fileData;
+        if (pdf.url) {
+          fileData = pdf.url;
+        } else if (pdf.base64) {
+          fileData = `data:application/pdf;base64,${this.extractBase64(pdf.base64)}`;
+        } else {
+          continue;
+        }
+        content.push({
+          type: "file",
+          file: {
+            filename: "document.pdf",
+            file_data: fileData
+          }
+        });
+      }
+    }
+    return [{ role: "user", content }];
+  }
+  /**
+   * Extract base64 data from a data URL or return as-is if already raw base64
+   */
+  extractBase64(input) {
+    if (input.startsWith("data:")) {
+      const base64Part = input.split(",")[1];
+      if (!base64Part) {
+        throw new Error(`Invalid data URL format: ${input.substring(0, 50)}`);
+      }
+      return base64Part;
+    }
+    return input;
+  }
+  calculateCost(usage) {
+    if (!usage) return void 0;
+    const inputCostPer1k = 5e-3;
+    const outputCostPer1k = 0.015;
+    const inputCost = usage.prompt_tokens / 1e3 * inputCostPer1k;
+    const outputCost = usage.completion_tokens / 1e3 * outputCostPer1k;
+    return inputCost + outputCost;
+  }
+};
+
+// src/providers/anthropic.ts
+import { fetchWithTimeout as fetchWithTimeout2, DEFAULT_LIMITS as DEFAULT_LIMITS2, validateUrl, safeJsonParse as safeJsonParse2 } from "@doclo/core/security";
+import { detectMimeTypeFromBase64 } from "@doclo/core";
+function extractProviderFromModel2(model, defaultProvider) {
+  const slashIndex = model.indexOf("/");
+  return slashIndex > 0 ? model.substring(0, slashIndex) : defaultProvider;
+}
+var AnthropicProvider = class {
+  name;
+  capabilities = {
+    supportsStructuredOutput: true,
+    // via tool calling
+    supportsStreaming: true,
+    supportsImages: true,
+    supportsPDFs: true,
+    maxPDFPages: 100,
+    maxPDFSize: void 0,
+    // ~400k tokens with overhead
+    maxContextTokens: 2e5
+  };
+  config;
+  translator;
+  limits;
+  constructor(config) {
+    this.config = config;
+    const baseProvider = extractProviderFromModel2(config.model, "anthropic");
+    this.name = `${baseProvider}:${config.model}`;
+    this.translator = new SchemaTranslator();
+    this.limits = {
+      ...DEFAULT_LIMITS2,
+      ...config.limits || {}
+    };
+  }
+  async completeJson(params) {
+    const startTime = Date.now();
+    const mode = params.mode || (params.schema ? "strict" : "relaxed");
+    if (mode === "strict" && !params.schema) {
+      throw new Error('schema is required when mode is "strict"');
+    }
+    const shouldEmbedSchema = params.embedSchemaInPrompt !== false && params.schema;
+    let enhancedInput = params.input;
+    if (shouldEmbedSchema) {
+      const jsonSchema = this.translator.convertZodIfNeeded(params.schema);
+      const enhancedText = combineSchemaAndUserPrompt(
+        jsonSchema,
+        params.input.text || ""
+      );
+      enhancedInput = {
+        ...params.input,
+        text: enhancedText
+      };
+    }
+    const messages = await this.buildMessages(enhancedInput);
+    const useNewStructuredOutputs = this.supportsNewStructuredOutputs();
+    const requestBody = {
+      model: this.config.model,
+      max_tokens: params.max_tokens || 4096,
+      messages
+    };
+    if (mode === "relaxed") {
+      requestBody.messages.push({
+        role: "assistant",
+        content: "{"
+      });
+      if (process.env.DEBUG_PROVIDERS) {
+        console.log("[AnthropicProvider] Using relaxed JSON mode (prompt + prefilling)");
+      }
+    } else if (useNewStructuredOutputs) {
+      const jsonSchema = this.translator.convertZodIfNeeded(params.schema);
+      const fixedSchema = this.fixSchemaForStrictMode(jsonSchema);
+      if (process.env.DEBUG_PROVIDERS) {
+        console.log("[AnthropicProvider] Original schema:", JSON.stringify(jsonSchema, null, 2));
+        console.log("[AnthropicProvider] Fixed schema:", JSON.stringify(fixedSchema, null, 2));
+      }
+      requestBody.output_format = {
+        type: "json_schema",
+        schema: fixedSchema
+      };
+      if (process.env.DEBUG_PROVIDERS) {
+        console.log("[AnthropicProvider] Using NEW structured outputs API (strict mode)");
+      }
+    } else {
+      const tool = this.translator.toClaudeToolSchema(params.schema);
+      requestBody.tools = [tool];
+      requestBody.tool_choice = { type: "tool", name: "extract_data" };
+      if (process.env.DEBUG_PROVIDERS) {
+        console.log("[AnthropicProvider] Using legacy tool calling approach (strict mode)");
+      }
+    }
+    if (this.config.via !== "openrouter" && params.reasoning) {
+      const thinkingConfig = this.buildNativeThinkingConfig(params.reasoning, params.max_tokens);
+      if (thinkingConfig) {
+        requestBody.thinking = thinkingConfig;
+      }
+    }
+    let response;
+    let parsed;
+    let inputTokens;
+    let outputTokens;
+    let costUSD;
+    if (this.config.via === "openrouter") {
+      const useNewStructuredOutputs2 = this.supportsNewStructuredOutputs();
+      const openRouterRequest = this.translateToOpenRouterFormat(messages, params.schema, mode, params.max_tokens, params.reasoning);
+      if (process.env.DEBUG_PROVIDERS) {
+        console.log("[AnthropicProvider] OpenRouter request body (messages):");
+        console.log(JSON.stringify(openRouterRequest.messages, null, 2));
+        console.log("[AnthropicProvider] Using new structured outputs:", useNewStructuredOutputs2);
+      }
+      response = await fetchWithTimeout2("https://openrouter.ai/api/v1/chat/completions", {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "Authorization": `Bearer ${this.config.apiKey}`,
+          "HTTP-Referer": "https://github.com/docloai/sdk",
+          "X-Title": "Doclo SDK"
+        },
+        body: JSON.stringify(openRouterRequest)
+      }, this.limits.REQUEST_TIMEOUT);
+      if (!response.ok) {
+        const error = await response.text();
+        throw new Error(`Anthropic API error (${response.status}): ${error}`);
+      }
+      const data = await response.json();
+      const message = data.choices?.[0]?.message;
+      let content = message?.content ?? (useNewStructuredOutputs2 ? "{}" : "}");
+      if (!useNewStructuredOutputs2) {
+        content = "{" + content;
+      }
+      const reasoning = message?.reasoning;
+      const reasoning_details = message?.reasoning_details;
+      content = content.replace(/^```json\s*\n?/, "").replace(/\n?```\s*$/, "").trim();
+      content = content.replace(/\*\*/g, "").replace(/\*/g, "");
+      const firstBrace = content.indexOf("{");
+      if (firstBrace !== -1) {
+        let braceCount = 0;
+        let jsonEnd = -1;
+        for (let i = firstBrace; i < content.length; i++) {
+          if (content[i] === "{") braceCount++;
+          if (content[i] === "}") braceCount--;
+          if (braceCount === 0) {
+            jsonEnd = i + 1;
+            break;
+          }
+        }
+        if (jsonEnd !== -1) {
+          content = content.substring(firstBrace, jsonEnd);
+        }
+      } else if (!content.startsWith("[")) {
+        throw new Error(`Claude did not return JSON. Response: ${content.substring(0, 200)}`);
+      }
+      content = content.trim();
+      parsed = safeJsonParse2(content);
+      if (mode === "relaxed" && this.looksLikeUnwrappedProperties(parsed)) {
+        parsed = this.wrapAsSchema(parsed);
+      }
+      inputTokens = data.usage?.prompt_tokens;
+      outputTokens = data.usage?.completion_tokens;
+      costUSD = data.usage?.total_cost ?? data.usage?.cost;
+      const cacheCreationInputTokens = data.usage?.cache_creation_input_tokens;
+      const cacheReadInputTokens = data.usage?.cache_read_input_tokens;
+      if (process.env.DEBUG_PROVIDERS) {
+        console.log("[AnthropicProvider] OpenRouter usage response:", JSON.stringify(data.usage, null, 2));
+        console.log("[AnthropicProvider] Extracted costUSD:", costUSD);
+        console.log("[AnthropicProvider] Cache creation tokens:", cacheCreationInputTokens);
+        console.log("[AnthropicProvider] Cache read tokens:", cacheReadInputTokens);
+      }
+      const latencyMs = Date.now() - startTime;
+      const baseProvider = extractProviderFromModel2(this.config.model, "anthropic");
+      return {
+        json: parsed,
+        rawText: JSON.stringify(parsed),
+        metrics: {
+          costUSD,
+          inputTokens,
+          outputTokens,
+          latencyMs,
+          attemptNumber: 1,
+          provider: baseProvider,
+          // Base provider (e.g., "anthropic" from "anthropic/claude-...")
+          model: this.config.model,
+          cacheCreationInputTokens,
+          cacheReadInputTokens
+        },
+        reasoning,
+        reasoning_details
+      };
+    } else {
+      const endpoint = this.config.baseUrl || "https://api.anthropic.com/v1";
+      const headers = {
+        "Content-Type": "application/json",
+        "x-api-key": this.config.apiKey,
+        "anthropic-version": "2023-06-01"
+      };
+      if (useNewStructuredOutputs) {
+        headers["anthropic-beta"] = "structured-outputs-2025-11-13";
+      }
+      response = await fetchWithTimeout2(`${endpoint}/messages`, {
+        method: "POST",
+        headers,
+        body: JSON.stringify(requestBody)
+      }, this.limits.REQUEST_TIMEOUT);
+      if (!response.ok) {
+        const error = await response.text();
+        throw new Error(`Anthropic API error (${response.status}): ${error}`);
+      }
+      const data = await response.json();
+      if (mode === "relaxed") {
+        const textBlock = data.content?.find((block) => block.type === "text");
+        if (!textBlock || !textBlock.text) {
+          throw new Error("Claude did not return structured output (relaxed mode)");
+        }
+        let content = "{" + textBlock.text;
+        const firstBrace = content.indexOf("{");
+        if (firstBrace !== -1) {
+          let braceCount = 0;
+          let jsonEnd = -1;
+          for (let i = firstBrace; i < content.length; i++) {
+            if (content[i] === "{") braceCount++;
+            if (content[i] === "}") braceCount--;
+            if (braceCount === 0) {
+              jsonEnd = i + 1;
+              break;
+            }
+          }
+          if (jsonEnd !== -1) {
+            content = content.substring(firstBrace, jsonEnd);
+          }
+        }
+        parsed = safeJsonParse2(content);
+      } else if (useNewStructuredOutputs) {
+        const textBlock = data.content?.find((block) => block.type === "text");
+        if (!textBlock || !textBlock.text) {
+          throw new Error("Claude did not return structured output via new API");
+        }
+        parsed = safeJsonParse2(textBlock.text);
+      } else {
+        const toolUseBlock = data.content?.find((block) => block.type === "tool_use");
+        if (!toolUseBlock || !toolUseBlock.input) {
+          throw new Error("Claude did not return structured output via tool calling");
+        }
+        parsed = toolUseBlock.input;
+      }
+      inputTokens = data.usage?.input_tokens;
+      outputTokens = data.usage?.output_tokens;
+      costUSD = this.calculateCost(data.usage);
+      const thinkingBlock = data.content?.find((block) => block.type === "thinking");
+      const reasoning = thinkingBlock?.thinking;
+      const latencyMs = Date.now() - startTime;
+      const baseProvider = extractProviderFromModel2(this.config.model, "anthropic");
+      return {
+        json: parsed,
+        rawText: JSON.stringify(parsed),
+        metrics: {
+          costUSD,
+          inputTokens,
+          outputTokens,
+          latencyMs,
+          attemptNumber: 1,
+          provider: baseProvider,
+          // Base provider (e.g., "anthropic" from "anthropic/claude-...")
+          model: this.config.model
+        },
+        reasoning,
+        reasoning_details: reasoning ? [{
+          type: "reasoning.text",
+          text: reasoning,
+          signature: null,
+          id: "thinking-1",
+          format: "anthropic-claude-v1"
+        }] : void 0
+      };
+    }
+  }
+  buildNativeThinkingConfig(reasoning, max_tokens) {
+    if (!reasoning.effort && !reasoning.enabled) {
+      return void 0;
+    }
+    const effort = reasoning.effort || "medium";
+    const requestMaxTokens = max_tokens || 4096;
+    const effortRatios = { low: 0.2, medium: 0.5, high: 0.8 };
+    const ratio = effortRatios[effort];
+    const budget_tokens = Math.max(1024, Math.min(32e3, Math.floor(requestMaxTokens * ratio)));
+    return {
+      type: "enabled",
+      budget_tokens
+    };
+  }
+  translateToOpenRouterFormat(messages, schema, mode, max_tokens, reasoning) {
+    const useNewStructuredOutputs = this.supportsNewStructuredOutputs();
+    const systemMessage = {
+      role: "system",
+      content: mode === "strict" ? "You are a data extraction assistant. You must respond ONLY with valid JSON that matches the provided schema. Do not include any markdown formatting, explanations, or additional text." : "You are a data extraction assistant. You must respond ONLY with valid JSON. Do not include any markdown formatting, explanations, or additional text."
+    };
+    const messageArray = [systemMessage, ...messages];
+    const requestBody = {
+      model: this.config.model,
+      messages: messageArray,
+      // Enable usage tracking for OpenRouter cost info
+      usage: {
+        include: true
+      }
+    };
+    if (mode === "relaxed") {
+      requestBody.response_format = {
+        type: "json_object"
+      };
+    } else {
+      const openRouterSchema = this.translator.toClaudeOpenRouterSchema(schema);
+      const fixedSchema = this.fixSchemaForStrictMode(openRouterSchema);
+      if (process.env.DEBUG_PROVIDERS) {
+        console.log("[AnthropicProvider] Original schema:", JSON.stringify(openRouterSchema, null, 2));
+        console.log("[AnthropicProvider] Fixed schema:", JSON.stringify(fixedSchema, null, 2));
+      }
+      if (!useNewStructuredOutputs) {
+        messageArray.push({
+          role: "assistant",
+          content: "{"
+        });
+      }
+      requestBody.response_format = {
+        type: "json_schema",
+        json_schema: {
+          name: "extraction",
+          strict: true,
+          schema: fixedSchema
+        }
+      };
+    }
+    if (reasoning) {
+      requestBody.reasoning = this.buildReasoningConfig(reasoning, max_tokens);
+    }
+    return requestBody;
+  }
+  buildReasoningConfig(reasoning, max_tokens) {
+    const config = {};
+    if (reasoning.effort || reasoning.enabled) {
+      const effort = reasoning.effort || "medium";
+      const requestMaxTokens = max_tokens || 4096;
+      const effortRatios = { low: 0.2, medium: 0.5, high: 0.8 };
+      const ratio = effortRatios[effort];
+      const reasoningBudget = Math.max(1024, Math.min(32e3, Math.floor(requestMaxTokens * ratio)));
+      config.max_tokens = reasoningBudget;
+    }
+    if (reasoning.exclude !== void 0) {
+      config.exclude = reasoning.exclude;
+    }
+    return Object.keys(config).length > 0 ? config : void 0;
+  }
+  supportsNewStructuredOutputs() {
+    const model = this.config.model.toLowerCase();
+    const sonnetMatch = model.match(/sonnet[_-](\d+)[._-](\d+)/);
+    const opusMatch = model.match(/opus[_-](\d+)[._-](\d+)/);
+    if (sonnetMatch) {
+      const major = parseInt(sonnetMatch[1], 10);
+      const minor = parseInt(sonnetMatch[2], 10);
+      const version = major + minor / 10;
+      return version >= 4.5;
+    }
+    if (opusMatch) {
+      const major = parseInt(opusMatch[1], 10);
+      const minor = parseInt(opusMatch[2], 10);
+      const version = major + minor / 10;
+      return version >= 4.1;
+    }
+    return false;
+  }
+  fixSchemaForStrictMode(schema) {
+    const clonedSchema = JSON.parse(JSON.stringify(schema));
+    if (!clonedSchema.type) {
+      clonedSchema.type = "object";
+    }
+    const fixRecursive = (obj) => {
+      if (!obj || typeof obj !== "object") {
+        return obj;
+      }
+      if (obj.type === "object") {
+        obj.additionalProperties = false;
+        if (obj.properties) {
+          const allProps = Object.keys(obj.properties);
+          obj.required = allProps;
+          for (const key in obj.properties) {
+            obj.properties[key] = fixRecursive(obj.properties[key]);
+          }
+        }
+      }
+      if (obj.type === "array" && obj.items) {
+        obj.items = fixRecursive(obj.items);
+      }
+      ["anyOf", "oneOf", "allOf"].forEach((keyword) => {
+        if (obj[keyword] && Array.isArray(obj[keyword])) {
+          obj[keyword] = obj[keyword].map((s) => fixRecursive(s));
+        }
+      });
+      return obj;
+    };
+    return fixRecursive(clonedSchema);
+  }
+  async buildMessages(input) {
+    const content = [];
+    const hasMedia = input.images && input.images.length > 0 || input.pdfs && input.pdfs.length > 0;
+    if (process.env.DEBUG_PROVIDERS) {
+      console.log("[AnthropicProvider.buildMessages] Input state:");
+      console.log("  hasMedia:", hasMedia);
+      console.log("  input.images:", input.images?.length || 0);
+      console.log("  input.pdfs:", input.pdfs?.length || 0);
+      console.log("  input.text:", input.text ? `"${input.text.substring(0, 50)}..."` : "undefined");
+      console.log("  via:", this.config.via);
+    }
+    if (this.config.via === "openrouter") {
+      if (input.images && input.images.length > 0) {
+        for (const image of input.images) {
+          if (image.url) {
+            content.push({
+              type: "image_url",
+              image_url: { url: image.url }
+            });
+          } else if (image.base64) {
+            const actualMimeType = detectMimeTypeFromBase64(image.base64);
+            if (image.mimeType && image.mimeType !== actualMimeType) {
+              console.warn(
+                `[AnthropicProvider] MIME type mismatch detected: declared "${image.mimeType}", actual "${actualMimeType}". Using detected type "${actualMimeType}" to prevent API errors.`
+              );
+            }
+            content.push({
+              type: "image_url",
+              image_url: {
+                url: `data:${actualMimeType};base64,${this.extractBase64(image.base64)}`
+              }
+            });
+          }
+        }
+      }
+      if (input.pdfs && input.pdfs.length > 0) {
+        for (const pdf of input.pdfs) {
+          let fileData;
+          if (pdf.url) {
+            fileData = pdf.url;
+          } else if (pdf.base64) {
+            const actualMimeType = detectMimeTypeFromBase64(pdf.base64);
+            if (actualMimeType !== "application/pdf") {
+              console.warn(
+                `[AnthropicProvider] PDF MIME type mismatch: expected "application/pdf", detected "${actualMimeType}". Using detected type.`
+              );
+            }
+            fileData = `data:${actualMimeType};base64,${this.extractBase64(pdf.base64)}`;
+          } else {
+            continue;
+          }
+          content.push({
+            type: "file",
+            file: {
+              filename: "document.pdf",
+              file_data: fileData
+            }
+          });
+        }
+      }
+      if (hasMedia) {
+        const textContent = input.text || "Extract the requested information from the document.";
+        if (process.env.DEBUG_PROVIDERS) {
+          console.log("[AnthropicProvider.buildMessages] Adding text block with cache_control");
+          console.log("  textContent:", textContent);
+        }
+        content.push({
+          type: "text",
+          text: textContent,
+          cache_control: { type: "ephemeral" }
+        });
+      } else if (input.text) {
+        content.push({
+          type: "text",
+          text: input.text
+        });
+      }
+    } else {
+      if (input.text) {
+        content.push({ type: "text", text: input.text });
+      }
+      if (input.images && input.images.length > 0) {
+        for (const image of input.images) {
+          if (image.url) {
+            const base64 = await this.urlToBase64(image.url);
+            content.push({
+              type: "image",
+              source: {
+                type: "base64",
+                media_type: image.mimeType,
+                data: base64
+              }
+            });
+          } else if (image.base64) {
+            content.push({
+              type: "image",
+              source: {
+                type: "base64",
+                media_type: image.mimeType,
+                data: this.extractBase64(image.base64)
+              }
+            });
+          }
+        }
+      }
+      if (input.pdfs && input.pdfs.length > 0) {
+        for (const pdf of input.pdfs) {
+          if (pdf.fileId) {
+            content.push({
+              type: "document",
+              source: {
+                type: "file",
+                file_id: pdf.fileId
+              }
+            });
+          } else if (pdf.base64) {
+            content.push({
+              type: "document",
+              source: {
+                type: "base64",
+                media_type: "application/pdf",
+                data: this.extractBase64(pdf.base64)
+              }
+            });
+          } else if (pdf.url) {
+            const base64 = await this.urlToBase64(pdf.url);
+            content.push({
+              type: "document",
+              source: {
+                type: "base64",
+                media_type: "application/pdf",
+                data: base64
+              }
+            });
+          }
+        }
+      }
+    }
+    if (process.env.DEBUG_PROVIDERS) {
+      console.log("[AnthropicProvider.buildMessages] Final content array length:", content.length);
+      console.log("[AnthropicProvider.buildMessages] Final content array:", JSON.stringify(content, null, 2));
+    }
+    return [{ role: "user", content }];
+  }
+  async urlToBase64(url) {
+    validateUrl(url);
+    const response = await fetchWithTimeout2(url, {}, this.limits.REQUEST_TIMEOUT);
+    if (!response.ok) {
+      throw new Error(`Failed to fetch URL: ${url}`);
+    }
+    const buffer = await response.arrayBuffer();
+    return Buffer.from(buffer).toString("base64");
+  }
+  /**
+   * Extract base64 data from a data URL or return as-is if already raw base64
+   */
+  extractBase64(input) {
+    if (input.startsWith("data:")) {
+      const base64Part = input.split(",")[1];
+      if (!base64Part) {
+        throw new Error(`Invalid data URL format: ${input.substring(0, 50)}`);
+      }
+      return base64Part;
+    }
+    return input;
+  }
+  calculateCost(usage) {
+    if (!usage) return void 0;
+    const inputCostPer1k = 3e-3;
+    const outputCostPer1k = 0.015;
+    const inputCost = usage.input_tokens / 1e3 * inputCostPer1k;
+    const outputCost = usage.output_tokens / 1e3 * outputCostPer1k;
+    return inputCost + outputCost;
+  }
+  /**
+   * Detect if a parsed JSON object looks like unwrapped JSON Schema properties
+   * (e.g., missing the root "type": "object" and "properties": {...} wrapper)
+   */
+  looksLikeUnwrappedProperties(obj) {
+    if (!obj || typeof obj !== "object" || Array.isArray(obj)) {
+      return false;
+    }
+    if (obj.type === "object" && obj.properties) {
+      return false;
+    }
+    const keys = Object.keys(obj);
+    if (keys.length === 0) {
+      return false;
+    }
+    let schemaPropertyCount = 0;
+    for (const key of keys) {
+      const value = obj[key];
+      if (value && typeof value === "object" && "type" in value) {
+        schemaPropertyCount++;
+      }
+    }
+    return schemaPropertyCount / keys.length > 0.5;
+  }
+  /**
+   * Wrap unwrapped properties into a proper JSON Schema structure
+   */
+  wrapAsSchema(unwrapped) {
+    const required = [];
+    for (const [key, value] of Object.entries(unwrapped)) {
+      if (value && typeof value === "object") {
+        const propDef = value;
+        if (!propDef.type || (propDef.type === "string" || propDef.type === "number" || propDef.type === "boolean" || propDef.type === "integer")) {
+          required.push(key);
+        } else if (propDef.type === "object" || propDef.type === "array") {
+          required.push(key);
+        }
+      }
+    }
+    return {
+      type: "object",
+      properties: unwrapped,
+      required
+    };
+  }
+};
+
+// src/providers/google.ts
+import { fetchWithTimeout as fetchWithTimeout3, validateUrl as validateUrl2, DEFAULT_LIMITS as DEFAULT_LIMITS3, safeJsonParse as safeJsonParse3 } from "@doclo/core/security";
+function extractProviderFromModel3(model, defaultProvider) {
+  const slashIndex = model.indexOf("/");
+  return slashIndex > 0 ? model.substring(0, slashIndex) : defaultProvider;
+}
+var GoogleProvider = class {
+  name;
+  capabilities = {
+    supportsStructuredOutput: true,
+    supportsStreaming: true,
+    supportsImages: true,
+    supportsPDFs: true,
+    maxPDFPages: 1e3,
+    // 1 page = 1 image
+    maxPDFSize: 50,
+    maxContextTokens: 1e6
+    // 1M tokens
+  };
+  config;
+  translator;
+  limits;
+  constructor(config) {
+    this.config = config;
+    const baseProvider = extractProviderFromModel3(config.model, "google");
+    this.name = `${baseProvider}:${config.model}`;
+    this.translator = new SchemaTranslator();
+    this.limits = {
+      ...DEFAULT_LIMITS3,
+      ...config.limits || {}
+    };
+    if (process.env.DEBUG_PROVIDERS) {
+      console.log("[GoogleProvider] Config:", JSON.stringify({
+        provider: config.provider,
+        model: config.model,
+        via: config.via,
+        hasApiKey: !!config.apiKey
+      }));
+    }
+  }
+  async completeJson(params) {
+    const startTime = Date.now();
+    const mode = params.mode || (params.schema ? "strict" : "relaxed");
+    if (mode === "strict" && !params.schema) {
+      throw new Error('schema is required when mode is "strict"');
+    }
+    const shouldEmbedSchema = params.embedSchemaInPrompt !== false && params.schema;
+    let enhancedInput = params.input;
+    if (shouldEmbedSchema) {
+      const jsonSchema = this.translator.convertZodIfNeeded(params.schema);
+      const enhancedText = combineSchemaAndUserPrompt(
+        jsonSchema,
+        params.input.text || ""
+      );
+      enhancedInput = {
+        ...params.input,
+        text: enhancedText
+      };
+    }
+    const contents = await this.buildContents(enhancedInput);
+    const requestBody = {
+      contents,
+      generationConfig: {
+        // Google's native responseSchema has strict validation issues with complex schemas.
+        // Use JSON mode without responseSchema - schema is already in the prompt via combineSchemaAndUserPrompt.
+        // See: https://ubaidullahmomer.medium.com/why-google-geminis-response-schema-isn-t-ready-for-complex-json-46f35c3aaaea
+        responseMimeType: "application/json"
+      }
+    };
+    if (process.env.DEBUG_PROVIDERS) {
+      console.log(`[GoogleProvider] Using ${mode} JSON mode (schema in prompt, no responseSchema)`);
+    }
+    if (this.config.via !== "openrouter" && params.reasoning) {
+      const thinkingConfig = this.buildNativeThinkingConfig(params.reasoning, params.max_tokens);
+      if (thinkingConfig) {
+        requestBody.generationConfig.thinking_config = thinkingConfig;
+      }
+    }
+    let response;
+    if (process.env.DEBUG_PROVIDERS) {
+      console.log("[GoogleProvider] Using via:", this.config.via, "Checking:", this.config.via === "openrouter");
+    }
+    if (this.config.via === "openrouter") {
+      const openRouterRequest = this.translateToOpenRouterFormat(contents, mode, params.max_tokens, params.reasoning);
+      response = await fetchWithTimeout3("https://openrouter.ai/api/v1/chat/completions", {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "Authorization": `Bearer ${this.config.apiKey}`,
+          "HTTP-Referer": "https://github.com/docloai/sdk",
+          "X-Title": "Doclo SDK"
+        },
+        body: JSON.stringify(openRouterRequest)
+      }, this.limits.REQUEST_TIMEOUT);
+    } else {
+      const endpoint = this.config.baseUrl || `https://generativelanguage.googleapis.com/v1beta/models/${this.config.model}:generateContent`;
+      validateUrl2(endpoint);
+      response = await fetchWithTimeout3(endpoint, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "x-goog-api-key": this.config.apiKey
+          // Use header instead of query param
+        },
+        body: JSON.stringify(requestBody)
+      }, this.limits.REQUEST_TIMEOUT);
+    }
+    if (!response.ok) {
+      const error = await response.text();
+      throw new Error(`Google API error (${response.status}): ${error}`);
+    }
+    const data = await response.json();
+    const latencyMs = Date.now() - startTime;
+    let content;
+    let inputTokens;
+    let outputTokens;
+    let costUSD;
+    if (this.config.via === "openrouter") {
+      const message = data.choices?.[0]?.message;
+      content = message?.content?.trim() || "{}";
+      inputTokens = data.usage?.prompt_tokens;
+      outputTokens = data.usage?.completion_tokens;
+      costUSD = data.usage?.total_cost ?? data.usage?.cost;
+      const reasoning = message?.reasoning;
+      const reasoning_details = message?.reasoning_details;
+      content = content.replace(/^```json\s*\n?/, "").replace(/\n?```\s*$/, "").trim();
+      const parsed = safeJsonParse3(content);
+      const baseProvider = extractProviderFromModel3(this.config.model, "google");
+      return {
+        json: parsed,
+        rawText: content,
+        metrics: {
+          costUSD,
+          inputTokens,
+          outputTokens,
+          latencyMs,
+          attemptNumber: 1,
+          provider: baseProvider,
+          // Base provider (e.g., "google" from "google/gemini-...")
+          model: this.config.model
+        },
+        reasoning,
+        reasoning_details
+      };
+    } else {
+      const candidate = data.candidates?.[0];
+      content = candidate?.content?.parts?.[0]?.text?.trim() || "{}";
+      inputTokens = data.usageMetadata?.promptTokenCount;
+      outputTokens = data.usageMetadata?.candidatesTokenCount;
+      costUSD = this.calculateCost(data.usageMetadata);
+      const thinkingPart = candidate?.content?.parts?.find((part) => part.thought === true);
+      const reasoning = thinkingPart?.text;
+      const parsed = safeJsonParse3(content);
+      const baseProvider = extractProviderFromModel3(this.config.model, "google");
+      return {
+        json: parsed,
+        rawText: content,
+        metrics: {
+          costUSD,
+          inputTokens,
+          outputTokens,
+          latencyMs,
+          attemptNumber: 1,
+          provider: baseProvider,
+          // Base provider (e.g., "google" from "google/gemini-...")
+          model: this.config.model
+        },
+        reasoning,
+        reasoning_details: reasoning ? [{
+          type: "reasoning.text",
+          text: reasoning,
+          signature: null,
+          id: "thinking-1",
+          format: "google-gemini-v1"
+        }] : void 0
+      };
+    }
+  }
+  buildNativeThinkingConfig(reasoning, max_tokens) {
+    if (!reasoning.effort && !reasoning.enabled) {
+      return void 0;
+    }
+    const effort = reasoning.effort || "medium";
+    const requestMaxTokens = max_tokens || 8192;
+    const effortRatios = { low: 0.2, medium: 0.5, high: 0.8 };
+    const ratio = effortRatios[effort];
+    const thinking_budget = Math.min(24576, Math.floor(requestMaxTokens * ratio));
+    return {
+      thinking_budget
+    };
+  }
+  translateToOpenRouterFormat(contents, mode, max_tokens, reasoning) {
+    const messages = [];
+    for (const content of contents) {
+      if (content.role === "user") {
+        const messageContent = [];
+        for (const part of content.parts) {
+          if (!part) continue;
+          if (part.text) {
+            messageContent.push({ type: "text", text: part.text });
+          } else if (part.inlineData) {
+            if (part.inlineData.mimeType === "application/pdf") {
+              messageContent.push({
+                type: "file",
+                file: {
+                  filename: "document.pdf",
+                  file_data: `data:${part.inlineData.mimeType};base64,${part.inlineData.data}`
+                }
+              });
+            } else {
+              messageContent.push({
+                type: "image_url",
+                image_url: {
+                  url: `data:${part.inlineData.mimeType};base64,${part.inlineData.data}`
+                }
+              });
+            }
+          }
+        }
+        messages.push({
+          role: "user",
+          content: messageContent.length === 1 && messageContent[0].type === "text" ? messageContent[0].text : messageContent
+        });
+      }
+    }
+    const requestBody = {
+      model: this.config.model,
+      messages,
+      // Enable usage tracking for OpenRouter cost info
+      usage: {
+        include: true
+      },
+      // Both relaxed and strict modes use json_object for Google via OpenRouter
+      // Schema is already in the prompt via combineSchemaAndUserPrompt
+      response_format: {
+        type: "json_object"
+      }
+    };
+    if (reasoning) {
+      requestBody.reasoning = this.buildReasoningConfig(reasoning, max_tokens);
+    }
+    return requestBody;
+  }
+  buildReasoningConfig(reasoning, max_tokens) {
+    const config = {};
+    if (reasoning.effort || reasoning.enabled) {
+      const effort = reasoning.effort || "medium";
+      const requestMaxTokens = max_tokens || 8192;
+      const effortRatios = { low: 0.2, medium: 0.5, high: 0.8 };
+      const ratio = effortRatios[effort];
+      const reasoningBudget = Math.floor(requestMaxTokens * ratio);
+      config.max_tokens = reasoningBudget;
+    }
+    if (reasoning.exclude !== void 0) {
+      config.exclude = reasoning.exclude;
+    }
+    return Object.keys(config).length > 0 ? config : void 0;
+  }
+  async buildContents(input) {
+    const parts = [];
+    if (input.text) {
+      parts.push({ text: input.text });
+    }
+    if (input.images && input.images.length > 0) {
+      for (const image of input.images) {
+        if (image.url) {
+          const base64 = await this.urlToBase64(image.url);
+          parts.push({
+            inlineData: {
+              mimeType: image.mimeType,
+              data: base64
+            }
+          });
+        } else if (image.base64) {
+          parts.push({
+            inlineData: {
+              mimeType: image.mimeType,
+              data: this.extractBase64(image.base64)
+            }
+          });
+        }
+      }
+    }
+    if (input.pdfs && input.pdfs.length > 0) {
+      for (const pdf of input.pdfs) {
+        if (pdf.fileId) {
+          parts.push({
+            fileData: {
+              fileUri: `https://generativelanguage.googleapis.com/v1beta/files/${pdf.fileId}`,
+              mimeType: "application/pdf"
+            }
+          });
+        } else if (pdf.base64) {
+          parts.push({
+            inlineData: {
+              mimeType: "application/pdf",
+              data: this.extractBase64(pdf.base64)
+            }
+          });
+        } else if (pdf.url) {
+          const base64 = await this.urlToBase64(pdf.url);
+          parts.push({
+            inlineData: {
+              mimeType: "application/pdf",
+              data: base64
+            }
+          });
+        }
+      }
+    }
+    return [{ role: "user", parts }];
+  }
+  async urlToBase64(url) {
+    validateUrl2(url);
+    const response = await fetchWithTimeout3(url, {}, this.limits.REQUEST_TIMEOUT);
+    if (!response.ok) {
+      throw new Error(`Failed to fetch URL: ${url}`);
+    }
+    const buffer = await response.arrayBuffer();
+    return Buffer.from(buffer).toString("base64");
+  }
+  /**
+   * Extract base64 data from a data URL or return as-is if already raw base64
+   */
+  extractBase64(input) {
+    if (input.startsWith("data:")) {
+      const base64Part = input.split(",")[1];
+      if (!base64Part) {
+        throw new Error(`Invalid data URL format: ${input.substring(0, 50)}`);
+      }
+      return base64Part;
+    }
+    return input;
+  }
+  calculateCost(usage) {
+    if (!usage) return void 0;
+    const inputCostPer1k = 25e-5;
+    const outputCostPer1k = 1e-3;
+    const inputCost = usage.promptTokenCount / 1e3 * inputCostPer1k;
+    const outputCost = usage.candidatesTokenCount / 1e3 * outputCostPer1k;
+    return inputCost + outputCost;
+  }
+};
+
+// src/providers/xai.ts
+import { fetchWithTimeout as fetchWithTimeout4, DEFAULT_LIMITS as DEFAULT_LIMITS4, safeJsonParse as safeJsonParse4 } from "@doclo/core/security";
+function extractProviderFromModel4(model, defaultProvider) {
+  const slashIndex = model.indexOf("/");
+  return slashIndex > 0 ? model.substring(0, slashIndex) : defaultProvider;
+}
+var XAIProvider = class {
+  name;
+  capabilities = {
+    supportsStructuredOutput: true,
+    supportsStreaming: false,
+    // Not with structured outputs
+    supportsImages: true,
+    supportsPDFs: true,
+    // via page-by-page images
+    maxPDFPages: void 0,
+    maxPDFSize: void 0,
+    maxContextTokens: 131072
+  };
+  config;
+  translator;
+  limits;
+  constructor(config) {
+    this.config = config;
+    const baseProvider = extractProviderFromModel4(config.model, "xai");
+    this.name = `${baseProvider}:${config.model}`;
+    this.translator = new SchemaTranslator();
+    this.limits = {
+      ...DEFAULT_LIMITS4,
+      ...config.limits || {}
+    };
+  }
+  async completeJson(params) {
+    const startTime = Date.now();
+    const mode = params.mode || (params.schema ? "strict" : "relaxed");
+    if (mode === "strict" && !params.schema) {
+      throw new Error('schema is required when mode is "strict"');
+    }
+    const shouldEmbedSchema = params.embedSchemaInPrompt !== false && params.schema;
+    let enhancedInput = params.input;
+    if (shouldEmbedSchema) {
+      const jsonSchema = this.translator.convertZodIfNeeded(params.schema);
+      const enhancedText = combineSchemaAndUserPrompt(
+        jsonSchema,
+        params.input.text || ""
+      );
+      enhancedInput = {
+        ...params.input,
+        text: enhancedText
+      };
+    }
+    const messages = await this.buildMessages(enhancedInput);
+    const requestBody = {
+      model: this.config.model,
+      messages,
+      max_tokens: params.max_tokens || 4096,
+      stream: false,
+      // Structured output doesn't support streaming
+      // Enable usage tracking for OpenRouter cost info
+      usage: {
+        include: true
+      }
+    };
+    if (mode === "relaxed") {
+      requestBody.response_format = {
+        type: "json_object"
+      };
+      if (process.env.DEBUG_PROVIDERS) {
+        console.log("[XAIProvider] Using relaxed JSON mode (json_object)");
+      }
+    } else {
+      const schema = this.translator.toOpenAISchema(params.schema);
+      const fixSchemaRecursive = (obj) => {
+        if (obj && typeof obj === "object") {
+          if (obj.type === "object" && obj.properties) {
+            const allProps = Object.keys(obj.properties);
+            obj.required = allProps;
+            obj.additionalProperties = false;
+            for (const key in obj.properties) {
+              obj.properties[key] = fixSchemaRecursive(obj.properties[key]);
+            }
+          } else if (obj.type === "array" && obj.items) {
+            obj.items = fixSchemaRecursive(obj.items);
+          }
+        }
+        return obj;
+      };
+      fixSchemaRecursive(schema);
+      if (process.env.DEBUG_PROVIDERS) {
+        console.log("[XAIProvider] Using strict JSON mode (json_schema)");
+      }
+      requestBody.response_format = {
+        type: "json_schema",
+        json_schema: {
+          name: "extraction",
+          schema
+        }
+      };
+    }
+    if (params.reasoning) {
+      requestBody.reasoning = this.buildReasoningConfig(params.reasoning);
+    }
+    if (this.config.via === "openrouter" && mode === "strict") {
+      requestBody.provider = {
+        require_parameters: true
+        // Only route to models supporting json_schema
+      };
+    }
+    const endpoint = this.config.via === "openrouter" ? "https://openrouter.ai/api/v1" : this.config.baseUrl || "https://api.x.ai/v1";
+    const headers = {
+      "Content-Type": "application/json",
+      "Authorization": `Bearer ${this.config.apiKey}`
+    };
+    if (this.config.via === "openrouter") {
+      headers["HTTP-Referer"] = "https://github.com/docloai/sdk";
+      headers["X-Title"] = "Doclo SDK";
+    }
+    const response = await fetchWithTimeout4(`${endpoint}/chat/completions`, {
+      method: "POST",
+      headers,
+      body: JSON.stringify(requestBody)
+    }, this.limits.REQUEST_TIMEOUT);
+    if (!response.ok) {
+      const error = await response.text();
+      throw new Error(`xAI API error (${response.status}): ${error}`);
+    }
+    const data = await response.json();
+    const latencyMs = Date.now() - startTime;
+    const message = data.choices?.[0]?.message;
+    const content = message?.content ?? "{}";
+    const parsed = safeJsonParse4(content);
+    const reasoning = message?.reasoning;
+    const reasoning_details = message?.reasoning_details;
+    let costUSD;
+    if (this.config.via === "openrouter") {
+      costUSD = data.usage?.total_cost ?? data.usage?.cost;
+    } else {
+      costUSD = this.calculateCost(data.usage);
+    }
+    const baseProvider = extractProviderFromModel4(this.config.model, "xai");
+    return {
+      json: parsed,
+      rawText: content,
+      metrics: {
+        costUSD,
+        inputTokens: data.usage?.prompt_tokens,
+        outputTokens: data.usage?.completion_tokens,
+        latencyMs,
+        attemptNumber: 1,
+        provider: baseProvider,
+        // Base provider (e.g., "x-ai" from "x-ai/grok-...")
+        model: this.config.model
+      },
+      reasoning,
+      reasoning_details
+    };
+  }
+  buildReasoningConfig(reasoning) {
+    const config = {};
+    if (reasoning.effort) {
+      config.effort = reasoning.effort;
+    } else if (reasoning.enabled) {
+      config.effort = "medium";
+    }
+    if (reasoning.exclude !== void 0) {
+      config.exclude = reasoning.exclude;
+    }
+    return Object.keys(config).length > 0 ? config : void 0;
+  }
+  async buildMessages(input) {
+    const content = [];
+    if (input.text) {
+      content.push({ type: "text", text: input.text });
+    }
+    if (input.images && input.images.length > 0) {
+      for (const image of input.images) {
+        if (image.url) {
+          content.push({
+            type: "image_url",
+            image_url: { url: image.url }
+          });
+        } else if (image.base64) {
+          content.push({
+            type: "image_url",
+            image_url: {
+              url: `data:${image.mimeType};base64,${this.extractBase64(image.base64)}`
+            }
+          });
+        }
+      }
+    }
+    if (input.pdfs && input.pdfs.length > 0) {
+      for (const pdf of input.pdfs) {
+        let fileData;
+        if (pdf.url) {
+          fileData = pdf.url;
+        } else if (pdf.base64) {
+          fileData = `data:application/pdf;base64,${this.extractBase64(pdf.base64)}`;
+        } else {
+          continue;
+        }
+        content.push({
+          type: "file",
+          file: {
+            filename: "document.pdf",
+            file_data: fileData
+          }
+        });
+      }
+    }
+    return [{ role: "user", content }];
+  }
+  /**
+   * Extract base64 data from a data URL or return as-is if already raw base64
+   */
+  extractBase64(input) {
+    if (input.startsWith("data:")) {
+      const base64Part = input.split(",")[1];
+      if (!base64Part) {
+        throw new Error(`Invalid data URL format: ${input.substring(0, 50)}`);
+      }
+      return base64Part;
+    }
+    return input;
+  }
+  calculateCost(usage) {
+    if (!usage) return void 0;
+    const inputCostPer1k = 5e-3;
+    const outputCostPer1k = 0.015;
+    const inputCost = usage.prompt_tokens / 1e3 * inputCostPer1k;
+    const outputCost = usage.completion_tokens / 1e3 * outputCostPer1k;
+    return inputCost + outputCost;
+  }
+};
+
+// src/fallback-manager.ts
+import {
+  executeHook,
+  createLogger
+} from "@doclo/core/observability";
+var FallbackManager = class {
+  config;
+  circuitBreakers;
+  constructor(config) {
+    this.config = config;
+    this.circuitBreakers = /* @__PURE__ */ new Map();
+  }
+  async executeWithFallback(input, schema, max_tokens, reasoning, mode, observability) {
+    const errors = [];
+    const logger = createLogger({
+      observability: observability?.config,
+      flowId: observability?.flowId,
+      executionId: observability?.executionId,
+      stepId: observability?.stepId,
+      traceContext: observability?.traceContext,
+      metadata: observability?.metadata
+    });
+    for (const [providerIndex, providerConfig] of this.config.providers.entries()) {
+      const providerKey = `${providerConfig.provider}:${providerConfig.model}`;
+      if (this.isCircuitOpen(providerKey)) {
+        logger.warn(`Circuit breaker open for ${providerKey}, skipping`);
+        if (observability?.config && observability.traceContext && observability.executionId) {
+          const cbState = this.circuitBreakers.get(providerKey);
+          const circuitBreakerContext = {
+            flowId: observability.flowId ?? "flow",
+            executionId: observability.executionId,
+            timestamp: Date.now(),
+            provider: providerConfig.provider,
+            model: providerConfig.model,
+            failureCount: cbState?.consecutiveFailures ?? 0,
+            threshold: this.config.circuitBreakerThreshold ?? 5,
+            cooldownMs: 6e4,
+            // Default cooldown
+            metadata: observability.metadata,
+            traceContext: observability.traceContext
+          };
+          await executeHook(observability.config.onCircuitBreakerTriggered, {
+            hookName: "onCircuitBreakerTriggered",
+            config: observability.config,
+            context: circuitBreakerContext
+          });
+        }
+        continue;
+      }
+      const provider = this.createProvider(providerConfig);
+      const maxRetriesForProvider = providerIndex === 0 ? this.config.primaryMaxRetries ?? this.config.maxRetries : this.config.maxRetries;
+      let lastError = null;
+      for (let attempt = 1; attempt <= maxRetriesForProvider; attempt++) {
+        try {
+          logger.info(`Attempting ${providerKey} (attempt ${attempt}/${maxRetriesForProvider})`);
+          const requestStartTime = Date.now();
+          if (observability?.config && observability.traceContext && observability.executionId) {
+            const providerRequestContext = {
+              flowId: observability.flowId ?? "flow",
+              executionId: observability.executionId,
+              stepId: observability.stepId,
+              timestamp: requestStartTime,
+              provider: providerConfig.provider,
+              model: providerConfig.model,
+              input,
+              schema,
+              attemptNumber: attempt,
+              maxAttempts: maxRetriesForProvider,
+              metadata: observability.metadata,
+              traceContext: observability.traceContext
+            };
+            await executeHook(observability.config.onProviderRequest, {
+              hookName: "onProviderRequest",
+              config: observability.config,
+              context: providerRequestContext
+            });
+          }
+          const response = await provider.completeJson({ input, schema, max_tokens, reasoning, mode });
+          if (this.validateResponse(response)) {
+            this.recordSuccess(providerKey);
+            if (observability?.config && observability.traceContext && observability.executionId) {
+              const providerResponseContext = {
+                flowId: observability.flowId ?? "flow",
+                executionId: observability.executionId,
+                stepId: observability.stepId,
+                timestamp: Date.now(),
+                startTime: requestStartTime,
+                duration: Date.now() - requestStartTime,
+                provider: providerConfig.provider,
+                model: providerConfig.model,
+                modelUsed: response.metrics.model,
+                output: response.json,
+                usage: {
+                  inputTokens: response.metrics.inputTokens ?? 0,
+                  outputTokens: response.metrics.outputTokens ?? 0,
+                  totalTokens: (response.metrics.inputTokens ?? 0) + (response.metrics.outputTokens ?? 0),
+                  cacheCreationInputTokens: response.metrics.cacheCreationInputTokens,
+                  cacheReadInputTokens: response.metrics.cacheReadInputTokens
+                },
+                cost: response.metrics.costUSD ?? 0,
+                finishReason: response.metrics.finishReason,
+                attemptNumber: attempt,
+                metadata: observability.metadata,
+                traceContext: observability.traceContext
+              };
+              await executeHook(observability.config.onProviderResponse, {
+                hookName: "onProviderResponse",
+                config: observability.config,
+                context: providerResponseContext
+              });
+            }
+            return {
+              ...response,
+              metrics: {
+                ...response.metrics,
+                attemptNumber: attempt
+              }
+            };
+          } else {
+            throw new Error("Response validation failed: incomplete or invalid data");
+          }
+        } catch (error) {
+          lastError = error;
+          logger.error(`${providerKey} attempt ${attempt} failed`, lastError, { providerKey, attempt });
+          if (!this.isRetryable(lastError) || attempt === maxRetriesForProvider) {
+            break;
+          }
+          const retryDelay = this.calculateDelay(attempt);
+          if (observability?.config && observability.traceContext && observability.executionId) {
+            const providerRetryContext = {
+              flowId: observability.flowId ?? "flow",
+              executionId: observability.executionId,
+              stepId: observability.stepId,
+              timestamp: Date.now(),
+              provider: providerConfig.provider,
+              model: providerConfig.model,
+              attemptNumber: attempt,
+              maxAttempts: maxRetriesForProvider,
+              error: lastError,
+              nextRetryDelay: retryDelay,
+              metadata: observability.metadata,
+              traceContext: observability.traceContext
+            };
+            await executeHook(observability.config.onProviderRetry, {
+              hookName: "onProviderRetry",
+              config: observability.config,
+              context: providerRetryContext
+            });
+          }
+          await this.sleep(retryDelay);
+        }
+      }
+      if (lastError) {
+        errors.push({ provider: providerKey, error: lastError });
+        this.recordFailure(providerKey);
+      }
+    }
+    throw new Error(
+      `All providers failed:
+${errors.map((e) => `  ${e.provider}: ${e.error.message}`).join("\n")}`
+    );
+  }
+  createProvider(config) {
+    return createProviderFromRegistry(config);
+  }
+  validateResponse(response) {
+    if (!response.json || typeof response.json !== "object") {
+      return false;
+    }
+    return true;
+  }
+  isRetryable(error) {
+    const message = error.message.toLowerCase();
+    const retryablePatterns = [
+      "408",
+      "429",
+      "500",
+      "502",
+      "503",
+      "504",
+      "timeout",
+      "rate limit",
+      "overloaded"
+    ];
+    return retryablePatterns.some(
+      (pattern) => message.includes(pattern)
+    );
+  }
+  calculateDelay(attempt) {
+    if (!this.config.useExponentialBackoff) {
+      return this.config.retryDelay;
+    }
+    const exponentialDelay = this.config.retryDelay * Math.pow(2, attempt - 1);
+    const jitter = Math.random() * 1e3;
+    return Math.min(exponentialDelay + jitter, 3e4);
+  }
+  sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+  // Circuit breaker logic
+  isCircuitOpen(providerKey) {
+    const state = this.circuitBreakers.get(providerKey);
+    if (!state || !state.isOpen) return false;
+    if (state.lastFailureTime && Date.now() - state.lastFailureTime > 3e4) {
+      this.circuitBreakers.set(providerKey, {
+        consecutiveFailures: 0,
+        isOpen: false
+      });
+      return false;
+    }
+    return true;
+  }
+  recordSuccess(providerKey) {
+    this.circuitBreakers.set(providerKey, {
+      consecutiveFailures: 0,
+      isOpen: false
+    });
+  }
+  recordFailure(providerKey) {
+    const state = this.circuitBreakers.get(providerKey) || {
+      consecutiveFailures: 0,
+      isOpen: false
+    };
+    state.consecutiveFailures++;
+    state.lastFailureTime = Date.now();
+    const threshold = this.config.circuitBreakerThreshold || 3;
+    if (state.consecutiveFailures >= threshold) {
+      state.isOpen = true;
+      console.warn(`Circuit breaker opened for ${providerKey} after ${state.consecutiveFailures} failures`);
+    }
+    this.circuitBreakers.set(providerKey, state);
+  }
+};
+
+// src/adapter.ts
+function adaptToCoreLLMProvider(provider) {
+  return {
+    name: provider.name,
+    capabilities: {
+      supportsImages: true,
+      supportsPDFs: provider.capabilities.supportsPDFs,
+      maxPDFPages: provider.capabilities.maxPDFPages
+    },
+    async completeJson(input) {
+      let multimodalInput;
+      if (typeof input.prompt === "string") {
+        multimodalInput = { text: input.prompt };
+      } else {
+        multimodalInput = input.prompt;
+      }
+      const response = await provider.completeJson({
+        input: multimodalInput,
+        schema: input.schema,
+        max_tokens: input.max_tokens,
+        reasoning: input.reasoning
+      });
+      return {
+        json: response.json,
+        rawText: response.rawText,
+        costUSD: response.metrics.costUSD,
+        inputTokens: response.metrics.inputTokens,
+        outputTokens: response.metrics.outputTokens,
+        cacheCreationInputTokens: response.metrics.cacheCreationInputTokens,
+        cacheReadInputTokens: response.metrics.cacheReadInputTokens
+      };
+    }
+  };
+}
+
+// src/metadata.ts
+var SUPPORTED_IMAGE_TYPES = {
+  COMMON: ["image/png", "image/jpeg", "image/webp", "image/gif"],
+  EXTENDED: ["image/png", "image/jpeg", "image/webp", "image/gif", "image/bmp", "image/tiff", "image/heif"]
+};
+var PROVIDER_METADATA = {
+  openai: {
+    id: "openai",
+    name: "OpenAI",
+    vendor: "openai",
+    models: ["gpt-5.1", "gpt-4.1", "gpt-4.1-mini", "o3", "o3-mini", "o4-mini"],
+    detailedModels: [
+      {
+        id: "gpt-4.1",
+        name: "GPT-4.1",
+        openRouterId: "openai/gpt-4.1",
+        capabilities: { supportsReasoning: false },
+        limits: { maxContextTokens: 128e3, maxOutputTokens: 16384 },
+        pricing: { inputPer1k: 2e-3, outputPer1k: 8e-3 }
+      },
+      {
+        id: "gpt-4.1-mini",
+        name: "GPT-4.1 Mini",
+        openRouterId: "openai/gpt-4.1-mini",
+        capabilities: { supportsReasoning: false },
+        limits: { maxContextTokens: 128e3, maxOutputTokens: 16384 },
+        pricing: { inputPer1k: 4e-4, outputPer1k: 16e-4 }
+      },
+      {
+        id: "o3",
+        name: "o3",
+        openRouterId: "openai/o3",
+        capabilities: { supportsReasoning: true },
+        limits: { maxContextTokens: 2e5, maxOutputTokens: 1e5 },
+        pricing: { inputPer1k: 0.01, outputPer1k: 0.04 }
+      },
+      {
+        id: "o3-mini",
+        name: "o3-mini",
+        openRouterId: "openai/o3-mini",
+        capabilities: { supportsReasoning: true },
+        limits: { maxContextTokens: 2e5, maxOutputTokens: 1e5 },
+        pricing: { inputPer1k: 11e-4, outputPer1k: 44e-4 }
+      },
+      {
+        id: "o4-mini",
+        name: "o4-mini",
+        openRouterId: "openai/o4-mini",
+        capabilities: { supportsReasoning: true },
+        limits: { maxContextTokens: 2e5, maxOutputTokens: 1e5 },
+        pricing: { inputPer1k: 11e-4, outputPer1k: 44e-4 }
+      },
+      {
+        id: "gpt-5.1",
+        name: "GPT-5.1",
+        openRouterId: "openai/gpt-5.1",
+        capabilities: { supportsReasoning: true },
+        limits: { maxContextTokens: 256e3, maxOutputTokens: 32768 },
+        pricing: { inputPer1k: 5e-3, outputPer1k: 0.015 }
+      }
+    ],
+    accessMethods: {
+      native: {
+        available: true,
+        endpoint: "https://api.openai.com/v1",
+        requiresApiKey: true
+      },
+      openrouter: {
+        available: true,
+        modelPrefix: "openai/"
+      }
+    },
+    capabilities: {
+      supportsImages: true,
+      supportsPDFs: true,
+      supportsReasoning: true,
+      supportsStreaming: true,
+      supportsStructuredOutput: true
+    },
+    // LLM with vision - can work with raw documents OR parsed text
+    inputRequirements: {
+      inputType: "any",
+      acceptedMethods: ["url", "base64"]
+    },
+    compatibleNodes: {
+      parse: true,
+      // ✅ VLMProvider - can convert images/PDFs to text
+      extract: true,
+      // ✅ VLMProvider - can extract structured data
+      categorize: true,
+      // ✅ VLMProvider - can classify documents
+      qualify: true,
+      // ✅ VLMProvider - can assess quality
+      split: true
+      // ✅ VLMProvider - can detect document boundaries
+    },
+    inputFormats: {
+      images: {
+        mimeTypes: SUPPORTED_IMAGE_TYPES.COMMON,
+        methods: ["url", "base64"],
+        maxSize: 20,
+        // 20 MB per image
+        maxDimensions: void 0,
+        // Images resized server-side
+        notes: "Inline via image_url with data URL or HTTP URL. Large images auto-resized."
+      },
+      pdfs: {
+        supported: true,
+        methods: ["base64", "fileId"],
+        maxSize: 50,
+        // 50 MB per file, 50 MB total per request
+        maxPages: 100,
+        notes: "Inline via type: file with base64, or via Files API. Extracts text + images of each page. File URLs NOT supported for chat completions."
+      }
+    },
+    outputFormat: {
+      supportsJSON: true,
+      supportsReasoning: true,
+      tokenTracking: true,
+      costTracking: true
+    },
+    pricing: {
+      model: "per-token",
+      inputPer1k: 5e-3,
+      outputPer1k: 0.015,
+      currency: "USD",
+      notes: "Cost calculated from tokens. OpenRouter may include cost in response. GPT-4.1 baseline."
+    },
+    limits: {
+      maxContextTokens: 128e3,
+      maxOutputTokens: 16384,
+      requestsPerMinute: void 0
+    },
+    nativeAPI: {
+      imageFormat: 'type: "image_url", image_url: { url: "data:image/jpeg;base64,..." }',
+      pdfFormat: 'type: "file", file: { file_id: "..." } OR file: { filename: "...", file_data: "data:application/pdf;base64,..." }',
+      reasoningConfig: 'reasoning: { effort: "low"|"medium"|"high", exclude?: boolean }'
+    },
+    openRouterAPI: {
+      imageFormat: "Same as native (OpenAI-compatible)",
+      pdfFormat: "Same as native (OpenAI-compatible)",
+      reasoningConfig: "Same as native (OpenAI-compatible)",
+      differences: [
+        "File URLs not supported (base64 only)",
+        "Cost may be available via usage.total_cost or generation endpoint"
+      ]
+    }
+  },
+  anthropic: {
+    id: "anthropic",
+    name: "Anthropic (Claude)",
+    vendor: "anthropic",
+    models: ["claude-opus-4.5", "claude-sonnet-4.5", "claude-haiku-4.5", "claude-opus-4", "claude-sonnet-4"],
+    detailedModels: [
+      {
+        id: "claude-opus-4.5",
+        name: "Claude Opus 4.5",
+        openRouterId: "anthropic/claude-opus-4.5",
+        capabilities: { supportsReasoning: true },
+        limits: { maxContextTokens: 2e5, maxOutputTokens: 32e3 },
+        pricing: { inputPer1k: 0.015, outputPer1k: 0.075 }
+      },
+      {
+        id: "claude-sonnet-4.5",
+        name: "Claude Sonnet 4.5",
+        openRouterId: "anthropic/claude-sonnet-4.5",
+        // Reasoning available via toggle (extended thinking)
+        capabilities: { supportsReasoning: true },
+        limits: { maxContextTokens: 2e5, maxOutputTokens: 16e3 },
+        pricing: { inputPer1k: 3e-3, outputPer1k: 0.015 }
+      },
+      {
+        id: "claude-haiku-4.5",
+        name: "Claude Haiku 4.5",
+        openRouterId: "anthropic/claude-haiku-4.5",
+        // Reasoning available via toggle (extended thinking)
+        capabilities: { supportsReasoning: true },
+        limits: { maxContextTokens: 2e5, maxOutputTokens: 8192 },
+        pricing: { inputPer1k: 8e-4, outputPer1k: 4e-3 }
+      },
+      {
+        id: "claude-opus-4",
+        name: "Claude Opus 4",
+        openRouterId: "anthropic/claude-opus-4",
+        capabilities: { supportsReasoning: true },
+        limits: { maxContextTokens: 2e5, maxOutputTokens: 32e3 },
+        pricing: { inputPer1k: 0.015, outputPer1k: 0.075 }
+      },
+      {
+        id: "claude-sonnet-4",
+        name: "Claude Sonnet 4",
+        openRouterId: "anthropic/claude-sonnet-4",
+        // Reasoning available via toggle (extended thinking)
+        capabilities: { supportsReasoning: true },
+        limits: { maxContextTokens: 2e5, maxOutputTokens: 16e3 },
+        pricing: { inputPer1k: 3e-3, outputPer1k: 0.015 }
+      }
+    ],
+    accessMethods: {
+      native: {
+        available: true,
+        endpoint: "https://api.anthropic.com/v1",
+        requiresApiKey: true
+      },
+      openrouter: {
+        available: true,
+        modelPrefix: "anthropic/"
+      }
+    },
+    capabilities: {
+      supportsImages: true,
+      supportsPDFs: true,
+      supportsReasoning: true,
+      supportsStreaming: true,
+      supportsStructuredOutput: true
+    },
+    // LLM with vision - can work with raw documents OR parsed text
+    inputRequirements: {
+      inputType: "any",
+      acceptedMethods: ["base64"]
+      // URLs must be downloaded and converted
+    },
+    compatibleNodes: {
+      parse: true,
+      extract: true,
+      categorize: true,
+      qualify: true,
+      split: true
+    },
+    inputFormats: {
+      images: {
+        mimeTypes: SUPPORTED_IMAGE_TYPES.COMMON,
+        methods: ["base64"],
+        // URLs must be downloaded and converted
+        maxSize: 5,
+        // 5 MB per image (API), 10 MB (claude.ai)
+        maxDimensions: { width: 8e3, height: 8e3 },
+        // Standard limit, 2000x2000 for 20+ images
+        notes: "Native API requires base64. Max 100 images/request. Optimal at 1568px max dimension."
+      },
+      pdfs: {
+        supported: true,
+        methods: ["base64", "fileId"],
+        maxSize: 32,
+        // 32 MB per file
+        maxPages: 100,
+        // 100 pages for full visual analysis
+        notes: "Inline via type: document with base64, or via Files API (beta). PDFs over 100 pages: text-only processing."
+      }
+    },
+    outputFormat: {
+      supportsJSON: true,
+      supportsReasoning: true,
+      tokenTracking: true,
+      costTracking: true
+    },
+    pricing: {
+      model: "per-token",
+      inputPer1k: 3e-3,
+      outputPer1k: 0.015,
+      currency: "USD",
+      notes: "Cost calculated from tokens. OpenRouter may include cost in response. Claude 3.5 Sonnet baseline."
+    },
+    limits: {
+      maxContextTokens: 2e5,
+      maxOutputTokens: 8192,
+      requestsPerMinute: void 0
+    },
+    nativeAPI: {
+      imageFormat: 'type: "image", source: { type: "base64", media_type: "image/jpeg", data: "..." }',
+      pdfFormat: 'type: "document", source: { type: "base64"|"file", media_type: "application/pdf", data: "..." | file_id: "..." }',
+      reasoningConfig: 'thinking: { type: "enabled", budget_tokens: 1024-32000 }'
+    },
+    openRouterAPI: {
+      imageFormat: 'type: "image_url", image_url: { url: "data:image/jpeg;base64,..." }',
+      pdfFormat: 'type: "file", file: { filename: "...", file_data: "data:application/pdf;base64,..." }',
+      reasoningConfig: "reasoning: { max_tokens: number, exclude?: boolean }",
+      differences: [
+        "Uses OpenAI-compatible format (image_url, file types)",
+        "Reasoning uses max_tokens instead of budget_tokens",
+        'Response prefill trick ({ role: "assistant", content: "{" }) for strict JSON',
+        "Tool calling instead of native structured output"
+      ]
+    }
+  },
+  google: {
+    id: "google",
+    name: "Google (Gemini)",
+    vendor: "google",
+    models: ["gemini-3-pro", "gemini-2.5-pro", "gemini-2.5-flash", "gemini-2.5-flash-lite"],
+    detailedModels: [
+      {
+        id: "gemini-3-pro",
+        name: "Gemini 3 Pro",
+        openRouterId: "google/gemini-3-pro",
+        capabilities: { supportsReasoning: true },
+        limits: { maxContextTokens: 1e6, maxOutputTokens: 65536 },
+        pricing: { inputPer1k: 125e-5, outputPer1k: 5e-3 }
+      },
+      {
+        id: "gemini-2.5-pro",
+        name: "Gemini 2.5 Pro",
+        openRouterId: "google/gemini-2.5-pro-preview-06-05",
+        capabilities: { supportsReasoning: true },
+        limits: { maxContextTokens: 1e6, maxOutputTokens: 65536 },
+        pricing: { inputPer1k: 125e-5, outputPer1k: 5e-3 }
+      },
+      {
+        id: "gemini-2.5-flash",
+        name: "Gemini 2.5 Flash",
+        openRouterId: "google/gemini-2.5-flash-preview-09-2025",
+        capabilities: { supportsReasoning: false },
+        limits: { maxContextTokens: 1e6, maxOutputTokens: 8192 },
+        pricing: { inputPer1k: 15e-5, outputPer1k: 6e-4 }
+      },
+      {
+        id: "gemini-2.5-flash-lite",
+        name: "Gemini 2.5 Flash Lite",
+        openRouterId: "google/gemini-2.5-flash-lite",
+        capabilities: { supportsReasoning: false },
+        limits: { maxContextTokens: 1e6, maxOutputTokens: 8192 },
+        pricing: { inputPer1k: 75e-6, outputPer1k: 3e-4 }
+      }
+    ],
+    accessMethods: {
+      native: {
+        available: true,
+        endpoint: "https://generativelanguage.googleapis.com/v1beta",
+        requiresApiKey: true
+      },
+      openrouter: {
+        available: true,
+        modelPrefix: "google/"
+      }
+    },
+    capabilities: {
+      supportsImages: true,
+      supportsPDFs: true,
+      supportsReasoning: true,
+      supportsStreaming: true,
+      supportsStructuredOutput: true
+    },
+    // LLM with vision - can work with raw documents OR parsed text
+    inputRequirements: {
+      inputType: "any",
+      acceptedMethods: ["base64"]
+      // URLs are downloaded and converted
+    },
+    compatibleNodes: {
+      parse: true,
+      extract: true,
+      categorize: true,
+      qualify: true,
+      split: true
+    },
+    inputFormats: {
+      images: {
+        mimeTypes: [...SUPPORTED_IMAGE_TYPES.COMMON, "image/bmp", "image/tiff", "image/heif"],
+        methods: ["base64"],
+        // URLs are downloaded and converted
+        maxSize: 20,
+        // 20 MB inline data limit (File API: 2GB for Gemini 2.0)
+        maxDimensions: { width: 3072, height: 3072 },
+        // Images scaled to fit, padded to preserve ratio
+        notes: "Inline via inlineData. Max 3000 images/request. File API supports larger files (stored 48 hours)."
+      },
+      pdfs: {
+        supported: true,
+        methods: ["base64", "fileId"],
+        maxSize: 50,
+        // 50 MB limit (inline & File API)
+        maxPages: 1e3,
+        // 1000 pages max, each page = 258 tokens
+        notes: "Inline via inlineData OR File API. Pages scaled to 3072x3072 max. Native text not charged."
+      }
+    },
+    outputFormat: {
+      supportsJSON: true,
+      supportsReasoning: true,
+      tokenTracking: true,
+      costTracking: true
+    },
+    pricing: {
+      model: "per-token",
+      inputPer1k: 25e-5,
+      outputPer1k: 1e-3,
+      currency: "USD",
+      notes: "Cost calculated from tokens. OpenRouter may include cost in response. Gemini 2.5 Flash baseline."
+    },
+    limits: {
+      maxContextTokens: 1e6,
+      // 1M tokens
+      maxOutputTokens: 8192,
+      requestsPerMinute: void 0
+    },
+    nativeAPI: {
+      imageFormat: 'inlineData: { mimeType: "image/jpeg", data: "..." }',
+      pdfFormat: 'inlineData: { mimeType: "application/pdf", data: "..." } OR fileData: { fileUri: "...", mimeType: "application/pdf" }',
+      reasoningConfig: "generationConfig.thinking_config: { thinking_budget: number } (max 24576)"
+    },
+    openRouterAPI: {
+      imageFormat: 'type: "image_url", image_url: { url: "data:image/jpeg;base64,..." }',
+      pdfFormat: 'type: "file", file: { filename: "...", file_data: "data:application/pdf;base64,..." }',
+      reasoningConfig: "reasoning: { max_tokens: number, exclude?: boolean }",
+      differences: [
+        "Uses OpenAI-compatible format instead of parts/inlineData",
+        "Reasoning uses max_tokens instead of thinking_budget",
+        "Different content structure (messages vs contents.parts)"
+      ]
+    }
+  },
+  xai: {
+    id: "xai",
+    name: "xAI (Grok)",
+    vendor: "xai",
+    models: ["grok-4.1", "grok-4.1-fast", "grok-4", "grok-4-fast"],
+    detailedModels: [
+      {
+        id: "grok-4.1",
+        name: "Grok 4.1",
+        openRouterId: "x-ai/grok-4.1",
+        capabilities: { supportsReasoning: true },
+        limits: { maxContextTokens: 256e3, maxOutputTokens: 32768 },
+        pricing: { inputPer1k: 3e-3, outputPer1k: 0.015 }
+      },
+      {
+        id: "grok-4.1-fast",
+        name: "Grok 4.1 Fast",
+        openRouterId: "x-ai/grok-4.1-fast",
+        capabilities: { supportsReasoning: false },
+        limits: { maxContextTokens: 2e6, maxOutputTokens: 32768 },
+        pricing: { inputPer1k: 5e-3, outputPer1k: 0.025 }
+      },
+      {
+        id: "grok-4",
+        name: "Grok 4",
+        openRouterId: "x-ai/grok-4",
+        capabilities: { supportsReasoning: true },
+        limits: { maxContextTokens: 256e3, maxOutputTokens: 32768 },
+        pricing: { inputPer1k: 3e-3, outputPer1k: 0.015 }
+      },
+      {
+        id: "grok-4-fast",
+        name: "Grok 4 Fast",
+        openRouterId: "x-ai/grok-4-fast",
+        capabilities: { supportsReasoning: false },
+        limits: { maxContextTokens: 2e6, maxOutputTokens: 32768 },
+        pricing: { inputPer1k: 5e-3, outputPer1k: 0.025 }
+      }
+    ],
+    accessMethods: {
+      native: {
+        available: true,
+        endpoint: "https://api.x.ai/v1",
+        requiresApiKey: true
+      },
+      openrouter: {
+        available: true,
+        modelPrefix: "xai/"
+      }
+    },
+    capabilities: {
+      supportsImages: true,
+      supportsPDFs: true,
+      supportsReasoning: true,
+      supportsStreaming: false,
+      // Not with structured outputs
+      supportsStructuredOutput: true
+    },
+    // LLM with vision - can work with raw documents OR parsed text
+    inputRequirements: {
+      inputType: "any",
+      acceptedMethods: ["url", "base64"]
+    },
+    compatibleNodes: {
+      parse: true,
+      extract: true,
+      categorize: true,
+      qualify: true,
+      split: true
+    },
+    inputFormats: {
+      images: {
+        mimeTypes: ["image/jpeg", "image/png"],
+        // Only jpg/jpeg and png supported
+        methods: ["url", "base64"],
+        maxSize: 30,
+        // 30 MB per file (API), 25 MB (chat)
+        maxDimensions: void 0,
+        notes: "OpenAI-compatible format. Max 10 images via API. Only JPEG/PNG supported."
+      },
+      pdfs: {
+        supported: true,
+        methods: ["url", "base64"],
+        maxSize: 30,
+        // 30 MB per file
+        maxPages: void 0,
+        notes: "OpenAI-compatible format. Inline via type: file. Also supports DOCX, TXT, MD, CSV."
+      }
+    },
+    outputFormat: {
+      supportsJSON: true,
+      supportsReasoning: true,
+      tokenTracking: true,
+      costTracking: true
+    },
+    pricing: {
+      model: "per-token",
+      inputPer1k: 5e-3,
+      outputPer1k: 0.015,
+      currency: "USD",
+      notes: "Cost calculated from tokens. OpenRouter may include cost in response. Grok-4 baseline."
+    },
+    limits: {
+      maxContextTokens: 131072,
+      maxOutputTokens: void 0,
+      requestsPerMinute: void 0
+    },
+    nativeAPI: {
+      imageFormat: 'type: "image_url", image_url: { url: "data:image/jpeg;base64,..." }',
+      pdfFormat: 'type: "file", file: { filename: "...", file_data: "data:application/pdf;base64,..." }',
+      reasoningConfig: 'reasoning: { effort: "low"|"medium"|"high", exclude?: boolean }'
+    },
+    openRouterAPI: {
+      imageFormat: "Same as native (OpenAI-compatible)",
+      pdfFormat: "Same as native (OpenAI-compatible)",
+      reasoningConfig: "Same as native (OpenAI-compatible)",
+      differences: [
+        "Minimal differences - xAI uses OpenAI-compatible format",
+        "Cost tracking via usage.total_cost field in OpenRouter"
+      ]
+    }
+  }
+};
+function isImageTypeSupported(providerId, mimeType) {
+  const provider = PROVIDER_METADATA[providerId];
+  return provider.inputFormats.images.mimeTypes.includes(mimeType);
+}
+function supportsPDFsInline(providerId) {
+  const provider = PROVIDER_METADATA[providerId];
+  return provider.inputFormats.pdfs.supported && provider.inputFormats.pdfs.methods.includes("base64");
+}
+function getProvidersForNode(nodeType) {
+  return Object.values(PROVIDER_METADATA).filter(
+    (provider) => provider.compatibleNodes[nodeType]
+  );
+}
+function isProviderCompatibleWithNode(providerId, nodeType) {
+  return PROVIDER_METADATA[providerId].compatibleNodes[nodeType];
+}
+function estimateCost(providerId, inputTokens, outputTokens) {
+  const provider = PROVIDER_METADATA[providerId];
+  const inputCost = inputTokens / 1e3 * provider.pricing.inputPer1k;
+  const outputCost = outputTokens / 1e3 * provider.pricing.outputPer1k;
+  return inputCost + outputCost;
+}
+function getCheapestProvider(inputTokens, outputTokens) {
+  const providers = Object.values(PROVIDER_METADATA);
+  return providers.reduce((cheapest, current) => {
+    const cheapestCost = estimateCost(cheapest.id, inputTokens, outputTokens);
+    const currentCost = estimateCost(current.id, inputTokens, outputTokens);
+    return currentCost < cheapestCost ? current : cheapest;
+  });
+}
+function compareNativeVsOpenRouter(providerId) {
+  const provider = PROVIDER_METADATA[providerId];
+  return {
+    provider: provider.name,
+    nativeAvailable: provider.accessMethods.native.available,
+    openRouterAvailable: provider.accessMethods.openrouter.available,
+    differences: provider.openRouterAPI.differences
+  };
+}
+
+// src/index.ts
+if (!providerRegistry.has("openai")) {
+  providerRegistry.register("openai", (config) => new OpenAIProvider(config));
+}
+if (!providerRegistry.has("anthropic")) {
+  providerRegistry.register("anthropic", (config) => new AnthropicProvider(config));
+}
+if (!providerRegistry.has("google")) {
+  providerRegistry.register("google", (config) => new GoogleProvider(config));
+}
+if (!providerRegistry.has("xai")) {
+  providerRegistry.register("xai", (config) => new XAIProvider(config));
+}
+function createVLMProvider(config) {
+  let internalProvider;
+  const providerConfig = {
+    provider: config.provider,
+    model: config.model,
+    apiKey: config.apiKey,
+    via: config.via,
+    baseUrl: config.baseUrl
+  };
+  internalProvider = createProviderFromRegistry(providerConfig);
+  return {
+    name: internalProvider.name,
+    capabilities: {
+      supportsImages: true,
+      supportsPDFs: internalProvider.capabilities.supportsPDFs,
+      maxPDFPages: internalProvider.capabilities.maxPDFPages
+    },
+    async completeJson(input) {
+      let multimodalInput;
+      if (typeof input.prompt === "string") {
+        multimodalInput = { text: input.prompt };
+      } else {
+        multimodalInput = input.prompt;
+      }
+      const response = await internalProvider.completeJson({
+        input: multimodalInput,
+        schema: input.schema,
+        max_tokens: input.max_tokens,
+        reasoning: input.reasoning
+      });
+      return {
+        json: response.json,
+        rawText: response.rawText,
+        costUSD: response.metrics.costUSD,
+        inputTokens: response.metrics.inputTokens,
+        outputTokens: response.metrics.outputTokens
+      };
+    }
+  };
+}
+function buildLLMProvider(config) {
+  const manager = new FallbackManager(config);
+  let observabilityContext;
+  const coreProvider = {
+    name: config.providers.map((p) => `${p.provider}:${p.model}`).join(" -> "),
+    capabilities: {
+      supportsImages: true,
+      supportsPDFs: true,
+      maxPDFPages: Math.min(...config.providers.map((_) => 100))
+    },
+    async completeJson(input) {
+      let multimodalInput;
+      if (typeof input.prompt === "string") {
+        multimodalInput = { text: input.prompt };
+      } else {
+        multimodalInput = input.prompt;
+      }
+      const response = await manager.executeWithFallback(
+        multimodalInput,
+        input.schema,
+        input.max_tokens,
+        input.reasoning,
+        void 0,
+        // mode - defaults to strict when schema provided
+        observabilityContext
+      );
+      return {
+        json: response.json,
+        rawText: response.rawText,
+        costUSD: response.metrics.costUSD,
+        inputTokens: response.metrics.inputTokens,
+        outputTokens: response.metrics.outputTokens,
+        cacheCreationInputTokens: response.metrics.cacheCreationInputTokens,
+        cacheReadInputTokens: response.metrics.cacheReadInputTokens
+      };
+    }
+  };
+  coreProvider.__setObservabilityContext = (ctx) => {
+    observabilityContext = ctx;
+  };
+  return coreProvider;
+}
+export {
+  AnthropicProvider,
+  FallbackManager,
+  GoogleProvider,
+  OpenAIProvider,
+  PROVIDER_METADATA,
+  SUPPORTED_IMAGE_TYPES,
+  SchemaTranslator,
+  XAIProvider,
+  adaptToCoreLLMProvider,
+  buildLLMProvider,
+  buildSchemaPromptSection,
+  combineSchemaAndUserPrompt,
+  compareNativeVsOpenRouter,
+  createProviderFromRegistry,
+  createVLMProvider,
+  estimateCost,
+  formatSchemaForPrompt,
+  getCheapestProvider,
+  getProvidersForNode,
+  isImageTypeSupported,
+  isProviderCompatibleWithNode,
+  providerRegistry,
+  registerProvider,
+  supportsPDFsInline
+};
+//# sourceMappingURL=index.js.map