multiwoven-integrations 0.40.1 → 0.41.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d02ac40ce23d00833bf9387f1363d3f871c0abdfb500c235e3d44a37110c9d8f
-  data.tar.gz: e76e2c81bf09fc64962b2639addb8d11ff7d9ad37a38c88b1267e0778d77bd95
+  metadata.gz: ad58beae1f92f76c184383a3e8c1741ee51356e6f3692bfae35ec73be5f9e351
+  data.tar.gz: 3b8e0bd9360c53a532157172c2e70d0a38d53a3c8aa9f26d11af35b99082f912
 SHA512:
-  metadata.gz: 2bf4882833f8c7e2f823b0077b3a4402d78f5c6acbdee0dc068063dd0be1310b0005c3f73305f26389e4bbf34d17ed6011aa6251852dfc0b17a7956a2928bba2
-  data.tar.gz: d460e9bd2b1e2b26fff0c1dd33148952c5f8f1d241cb208bc4da5c4cefbdd9e33b16e6e90ecc449c8e1ddd047b2a40c718dcb51f20aa0b7a9e4d61e21f301229
+  metadata.gz: 317c2605f975ec6726413bb1d26cb8716f5c4150c515bb666f26ec3a7265f4a905eddef60d739effc07d492dc9238bb2c1ecef9358118921b3e88e52a90f58c9
+  data.tar.gz: ca2256921a2839449fee7e9a97d3c76a6ea54474df87f67124c8f5e31acc58df4077f34c7762e0525c66ea2fcc2536adcb21887eea41f0b0d7c949d7bfc479eb

data/lib/multiwoven/integrations/config.rb

@@ -3,11 +3,14 @@
 module Multiwoven
   module Integrations
     class Config
-      attr_accessor :logger, :exception_reporter
+      # cache: optional host store responding to read(key), write(key, value,
+      # expires_in:) and delete(key). Without one, caching is a per-process memo.
+      attr_accessor :logger, :exception_reporter, :cache
 
       def initialize(params = {})
         @logger = params[:logger]
         @exception_reporter = params[:exception_reporter]
+        @cache = params[:cache]
       end
     end
   end

data/lib/multiwoven/integrations/core/base_connector.rb

@@ -8,20 +8,47 @@ module Multiwoven
       include Constants
 
       def connector_spec
-        @connector_spec ||= begin
-          spec_json = keys_to_symbols(read_json(CONNECTOR_SPEC_PATH)).to_json
-          # returns Protocol::ConnectorSpecification
-          ConnectorSpecification.from_json(spec_json)
-        end
+        @connector_spec ||= ConnectorSpecification.from_json(keys_to_symbols(read_json(CONNECTOR_SPEC_PATH)).to_json)
       end
 
       def meta_data
+        return @meta_data if @meta_data
+
         client_meta_data = read_json(META_DATA_PATH).deep_symbolize_keys
         icon_name = client_meta_data[:data][:icon]
         icon_url = "https://raw.githubusercontent.com/Multiwoven/multiwoven/main/integrations#{relative_path}/#{icon_name}"
         client_meta_data[:data][:icon] = icon_url
         # returns hash
-        @meta_data ||= client_meta_data
+        @meta_data = client_meta_data
+      end
+
+      def model_catalog
+        @model_catalog ||= ModelCatalog.new(models: (live_models + curated_models).uniq { |model| model[:id] })
+      rescue Dry::Struct::Error => e
+        Integrations::Service.logger.error("#{self.class}: unusable model catalog: #{e.message}")
+        @model_catalog = ModelCatalog.new(models: [])
+      end
+
+      # Symbolized to match models from upstream; read_json hands back string keys,
+      # which leaves callers reading nil.
+      def curated_models
+        @curated_models ||= Array(read_json(MODELS_SPEC_PATH)["models"]).map(&:deep_symbolize_keys)
+      rescue Errno::ENOENT
+        @curated_models = []
+      rescue StandardError => e
+        Integrations::Service.logger.error("#{self.class}: unusable models.json: #{e.message}")
+        @curated_models = []
+      end
+
+      def live_models
+        slug = meta_data[:data][:openrouter_slug]
+        return [] if slug.blank?
+
+        overrides = meta_data[:data][:model_id_overrides] || {}
+        Integrations::Core::OpenRouterCatalog.fetch.models_for(slug).map do |model|
+          pinned = overrides[model[:id].to_sym] || overrides[model[:id].to_s]
+          pinned.present? ? model.merge(id: pinned) : model
+        end
       end
 
       def relative_path

data/lib/multiwoven/integrations/core/constants.rb

@@ -7,6 +7,7 @@ module Multiwoven
       META_DATA_PATH = "config/meta.json"
       CONNECTOR_SPEC_PATH = "config/spec.json"
       CATALOG_SPEC_PATH   = "config/catalog.json"
+      MODELS_SPEC_PATH    = "config/models.json"
       SNOWFLAKE_MAC_DRIVER_PATH = "/opt/snowflake/snowflakeodbc/lib/universal/libSnowflake.dylib"
       DATABRICKS_MAC_DRIVER_PATH = "/Library/simba/spark/lib/libsparkodbc_sb64-universal.dylib"
 

data/lib/multiwoven/integrations/core/open_router_catalog.rb

@@ -0,0 +1,212 @@
+# frozen_string_literal: true
+
+module Multiwoven
+  module Integrations::Core
+    # Live model metadata from OpenRouter's public /models endpoint, so a connector
+    # need not ship prices that go stale. Providers opt in with an openrouter_slug;
+    # embeddings and partner-hosted models stay curated in models.json.
+    class OpenRouterCatalog
+      MODELS_URL = "https://openrouter.ai/api/v1/models"
+      CACHE_KEY = "multiwoven_open_router_catalog_v1"
+      CACHE_TTL = 86_400
+      REQUEST_CONFIG = { timeout: 10, open_timeout: 5 }.freeze
+      PER_MILLION = 1_000_000
+
+      Result = Struct.new(:models_by_slug, :fetched_at, :source, keyword_init: true) do
+        def models_for(slug)
+          return [] if slug.blank?
+
+          models_by_slug.fetch(slug.to_s.downcase, [])
+        end
+      end
+
+      class << self
+        # Two layers: a host cache may be absent or a null store, so the memo is
+        # what prevents a re-fetch of half a megabyte per request.
+        def fetch
+          return @memo if live_memo?
+
+          result = to_result(cached_payload)
+          @memo = result if result.source == "live"
+          result
+        end
+
+        def reset!
+          @memo = nil
+          cache&.delete(CACHE_KEY)
+        rescue StandardError => e
+          log_cache_failure("delete", e)
+        end
+
+        private
+
+        def cache
+          Integrations::Service.config.cache
+        end
+
+        def live_memo?
+          @memo&.source == "live" && @memo.fetched_at && @memo.fetched_at > Time.now - CACHE_TTL
+        end
+
+        def cached_payload
+          store = cache
+          return build_payload if store.nil?
+
+          cached = read_cache(store)
+          return cached if live_payload?(cached)
+
+          payload = build_payload
+          write_cache(store, payload) if live_payload?(payload)
+          payload
+        end
+
+        # A failing host cache degrades to a direct fetch rather than taking the
+        # whole catalog down with it.
+        def read_cache(store)
+          store.read(CACHE_KEY)
+        rescue StandardError => e
+          log_cache_failure("read", e)
+          nil
+        end
+
+        def write_cache(store, payload)
+          store.write(CACHE_KEY, payload, expires_in: CACHE_TTL)
+        rescue StandardError => e
+          log_cache_failure("write", e)
+        end
+
+        def log_cache_failure(operation, error)
+          Integrations::Service.logger.error(
+            "OpenRouterCatalog: cache #{operation} failed: #{error.class}: #{error.message}"
+          )
+        end
+
+        def live_payload?(payload)
+          payload.present? && payload.with_indifferent_access[:source] == "live"
+        end
+
+        # Slugs stay strings because models_for looks them up that way; the model
+        # hashes are symbolized because every reader indexes them with symbols.
+        def symbolize_models(by_slug)
+          (by_slug || {}).each_with_object({}) do |(slug, models), acc|
+            acc[slug.to_s.downcase] = Array(models).map(&:deep_symbolize_keys)
+          end
+        end
+
+        def to_result(payload)
+          payload = payload.transform_keys(&:to_sym)
+          Result.new(
+            models_by_slug: symbolize_models(payload[:models_by_slug]),
+            fetched_at: payload[:fetched_at],
+            source: payload[:source]
+          )
+        end
+
+        def build_payload
+          response = Integrations::Core::HttpClient.request(
+            MODELS_URL, "GET", options: { config: REQUEST_CONFIG }
+          )
+          body = JSON.parse(response.body)
+          raise "OpenRouter returned no data" unless body["data"].is_a?(Array)
+
+          { models_by_slug: group_by_slug(body["data"]), fetched_at: Time.now, source: "live" }
+        rescue StandardError => e
+          # Fail soft: callers still see curated models rather than an exception.
+          Integrations::Service.logger.error("OpenRouterCatalog: #{e.class}: #{e.message}")
+          { models_by_slug: {}, fetched_at: Time.now, source: "unavailable" }
+        end
+
+        def group_by_slug(raw_models)
+          grouped = raw_models.each_with_object({}) do |raw, acc|
+            slug, = raw["id"].to_s.split("/", 2)
+            next if slug.blank?
+
+            (acc[slug.downcase] ||= []) << normalize(raw, slug.downcase)
+          end
+          grouped.transform_values { |models| sort_models(models) }
+        end
+
+        # Newest first: a live list has no curation.
+        def sort_models(models)
+          models.sort_by { |model| [-model[:released_at].to_i, model[:name].to_s.downcase] }
+                .each { |model| model.delete(:released_at) }
+        end
+
+        def normalize(raw, slug)
+          architecture = raw["architecture"] || {}
+          inputs = Array(architecture["input_modalities"])
+          outputs = Array(architecture["output_modalities"])
+          pricing = raw["pricing"] || {}
+
+          {
+            id: strip_slug(raw["id"]),
+            openrouter_id: raw["id"],
+            name: display_name(raw, slug),
+            model_type: outputs.include?("image") ? "vision" : "llm",
+            type: outputs.include?("image") ? "image" : "completion",
+            tasks: derive_tasks(raw, outputs),
+            capabilities: derive_capabilities(raw, inputs, pricing),
+            context_window: raw["context_length"]&.to_i,
+            max_output: raw.dig("top_provider", "max_completion_tokens")&.to_i,
+            pricing: {
+              input: per_million(pricing["prompt"]),
+              output: per_million(pricing["completion"]),
+              cached_read: per_million(pricing["input_cache_read"]),
+              cached_write: per_million(pricing["input_cache_write"]),
+              unit: "per_1m_tokens"
+            },
+            availability: "available",
+            unavailable_reason: nil,
+            released_at: raw["created"]
+          }
+        end
+
+        # Ids are "<provider-slug>/<model-slug>", and the slug is OpenRouter's own
+        # normalization — a provider may pin the real one.
+        def strip_slug(id)
+          id.to_s.split("/", 2).last.to_s
+        end
+
+        # Names are prefixed with the vendor ("OpenAI: GPT-4o") and the UI already
+        # shows it. Drop it only when the prefix really is the provider.
+        def display_name(raw, slug)
+          name = raw["name"].presence || strip_slug(raw["id"])
+          prefix, remainder = name.split(":", 2)
+          return name if remainder.blank?
+          return name unless prefix.to_s.downcase.gsub(/[^a-z0-9]/, "") == slug.gsub(/[^a-z0-9]/, "")
+
+          remainder.strip
+        end
+
+        def derive_tasks(raw, outputs)
+          tasks = []
+          tasks << "Text Generation" if outputs.include?("text")
+          tasks << "Text-to-Image" if outputs.include?("image")
+          params = Array(raw["supported_parameters"])
+          tasks << "Reasoning" if params.include?("reasoning") || params.include?("include_reasoning")
+          tasks.uniq
+        end
+
+        def derive_capabilities(raw, inputs, pricing)
+          params = Array(raw["supported_parameters"])
+          capabilities = []
+          capabilities << "Image analysis" if inputs.include?("image")
+          capabilities << "Documents" if inputs.include?("file")
+          capabilities << "Audio" if inputs.include?("audio")
+          capabilities << "Web search" if pricing["web_search"].present?
+          capabilities << "Tool use" if params.include?("tools")
+          capabilities << "Structured output" if params.include?("structured_outputs")
+          capabilities
+        end
+
+        # Quoted per token as strings; the contract is per million. A genuine zero
+        # stays 0.0, a missing field stays nil so the UI renders "—" not "$0".
+        def per_million(value)
+          return nil if value.nil? || value.to_s.strip.empty?
+
+          (value.to_f * PER_MILLION).round(4)
+        end
+      end
+    end
+  end
+end

data/lib/multiwoven/integrations/protocol/protocol.json

@@ -155,6 +155,60 @@
       },
       "additionalProperties": true
     },
+    "ModelCatalogType": {
+      "type": "string",
+      "enum": ["llm", "embedding", "vision"]
+    },
+    "ModelCatalogKind": {
+      "type": "string",
+      "enum": ["completion", "embedding", "image"]
+    },
+    "ModelCatalogAvailability": {
+      "type": "string",
+      "enum": ["available", "unavailable"]
+    },
+    "ModelCatalogPricing": {
+      "type": "object",
+      "properties": {
+        "input": { "type": ["number", "null"] },
+        "output": { "type": ["number", "null"] },
+        "cached_read": { "type": ["number", "null"] },
+        "cached_write": { "type": ["number", "null"] },
+        "unit": { "type": ["string", "null"], "default": "per_1m_tokens" }
+      },
+      "additionalProperties": true
+    },
+    "ModelCatalogEntry": {
+      "type": "object",
+      "properties": {
+        "id": { "type": "string" },
+        "name": { "type": "string" },
+        "model_type": { "$ref": "#/definitions/ModelCatalogType" },
+        "type": { "anyOf": [{ "$ref": "#/definitions/ModelCatalogKind" }, { "type": "null" }] },
+        "openrouter_id": { "type": ["string", "null"] },
+        "tasks": { "type": "array", "items": { "type": "string" } },
+        "capabilities": { "type": "array", "items": { "type": "string" } },
+        "context_window": { "type": ["integer", "null"] },
+        "max_output": { "type": ["integer", "null"] },
+        "pricing": { "anyOf": [{ "$ref": "#/definitions/ModelCatalogPricing" }, { "type": "null" }] },
+        "availability": { "$ref": "#/definitions/ModelCatalogAvailability" },
+        "unavailable_reason": { "type": ["string", "null"] }
+      },
+      "required": ["id", "name", "model_type"],
+      "additionalProperties": true
+    },
+    "ModelCatalog": {
+      "type": "object",
+      "properties": {
+        "models": {
+          "type": "array",
+          "items": {
+            "$ref": "#/definitions/ModelCatalogEntry"
+          }
+        }
+      },
+      "additionalProperties": true
+    },
     "SyncConfig": {
       "type": "object",
       "properties": {

data/lib/multiwoven/integrations/protocol/protocol.rb

@@ -18,8 +18,11 @@ module Multiwoven
     MultiwovenMessageType = Types::String.enum(
       "record", "log", "connector_spec",
       "connection_status", "catalog", "control",
-      "tracking"
+      "tracking", "model_catalog"
     )
+    ModelCatalogType = Types::String.enum("llm", "embedding", "vision")
+    ModelCatalogKind = Types::String.enum("completion", "embedding", "image")
+    ModelCatalogAvailability = Types::String.default("available").enum("available", "unavailable")
     ControlMessageType = Types::String.enum(
       "rate_limit", "connection_config", "full_refresh"
     )
@@ -166,6 +169,40 @@ module Multiwoven
       end
     end
 
+    class ModelCatalogPricing < ProtocolModel
+      attribute? :input, Types::Coercible::Float.optional
+      attribute? :output, Types::Coercible::Float.optional
+      attribute? :cached_read, Types::Coercible::Float.optional
+      attribute? :cached_write, Types::Coercible::Float.optional
+      attribute? :unit, Types::String.optional.default("per_1m_tokens")
+    end
+
+    class ModelCatalogEntry < ProtocolModel
+      attribute :id, Types::String
+      attribute :name, Types::String
+      attribute :model_type, ModelCatalogType
+      attribute? :type, ModelCatalogKind.optional
+      attribute? :openrouter_id, Types::String.optional
+      attribute :tasks, Types::Array.of(Types::String).default([].freeze)
+      attribute :capabilities, Types::Array.of(Types::String).default([].freeze)
+      attribute? :context_window, Types::Integer.optional
+      attribute? :max_output, Types::Integer.optional
+      attribute? :pricing, ModelCatalogPricing.optional
+      attribute :availability, ModelCatalogAvailability
+      attribute? :unavailable_reason, Types::String.optional
+    end
+
+    class ModelCatalog < ProtocolModel
+      attribute :models, Types::Array.of(ModelCatalogEntry).default([].freeze)
+
+      def to_multiwoven_message
+        MultiwovenMessage.new(
+          type: MultiwovenMessageType["model_catalog"],
+          model_catalog: self
+        )
+      end
+    end
+
     class IncrementStrategyConfig < ProtocolModel
       attr_accessor :offset, :limit, :offset_variable, :limit_variable
 
@@ -230,6 +267,7 @@ module Multiwoven
       attribute? :connection_status, ConnectionStatus.optional
       attribute? :connector_spec, ConnectorSpecification.optional
       attribute? :catalog, Catalog.optional
+      attribute? :model_catalog, ModelCatalog.optional
       attribute? :record, RecordMessage.optional
       attribute? :control, ControlMessage.optional
       attribute? :tracking, TrackingMessage.optional

data/lib/multiwoven/integrations/rollout.rb

@@ -2,7 +2,7 @@
 
 module Multiwoven
   module Integrations
-    VERSION = "0.40.1"
+    VERSION = "0.41.0"
 
     ENABLED_SOURCES = %w[
       Snowflake
@@ -27,6 +27,8 @@ module Multiwoven
       Anthropic
       AwsBedrockModel
       GenericOpenAI
+      GoogleGemini
+      JohnSnowLabs
       IntuitQuickBooks
       PineconeDB
       Qdrant

data/lib/multiwoven/integrations/service.rb

@@ -7,15 +7,17 @@ module Multiwoven
         yield(self.class.config) if block_given?
       end
       class << self
+        # deep_dup, not dup: the entries are the clients' own memoized metadata, so a
+        # shallow copy lets one caller's mutation reach every later caller.
         def connectors
-          {
-            source: build_connectors(
-              ENABLED_SOURCES, "Source"
-            ),
-            destination: build_connectors(
-              ENABLED_DESTINATIONS, "Destination"
-            )
-          }
+          built = built_connectors
+          { source: built[:source].deep_dup, destination: built[:destination].deep_dup }
+        end
+
+        # The build is memoized for the life of the process, so anything that
+        # changes what would be built has to clear it.
+        def reset_connectors!
+          @built_connectors = nil
         end
 
         def connector_class(connector_type, connector_name)
@@ -38,6 +40,13 @@ module Multiwoven
 
         private
 
+        def built_connectors
+          @built_connectors ||= {
+            source: build_connectors(ENABLED_SOURCES, "Source"),
+            destination: build_connectors(ENABLED_DESTINATIONS, "Destination")
+          }
+        end
+
         def build_connectors(enabled_connectors, type)
           enabled_connectors.map do |connector|
             client = connector_class(type, connector).new

data/lib/multiwoven/integrations/source/aisquared/config/meta.json

@@ -1,16 +1,22 @@
 {
   "data": {
     "name": "Aisquared",
-    "title": "AI Squared Bolt",
+    "title": "AISquared",
     "connector_type": "source",
     "category": "AI Model",
     "sub_category": "LLM",
+    "provider_type": "built_in",
+    "display_order": 10,
+    "description": "AISquared's own model portfolio \u2014 Bolt Instruct, Vision and Embedding models. Pre-configured with no setup required.",
     "documentation_url": "https://docs.squared.ai/activation/ai-ml-sources/aisquared-bolt",
     "github_issue_label": "source-aisquared-bolt",
     "icon": "icon.svg",
     "license": "MIT",
     "release_stage": "alpha",
     "support_level": "community",
-    "tags": ["language:ruby", "multiwoven"]
+    "tags": [
+      "language:ruby",
+      "multiwoven"
+    ]
   }
 }

data/lib/multiwoven/integrations/source/aisquared/config/models.json

@@ -0,0 +1,120 @@
+{
+  "models": [
+    {
+      "id": "bolt-instruct-1b",
+      "name": "Bolt-Instruct-1B",
+      "model_type": "llm",
+      "type": "completion",
+      "tasks": [
+        "Text Classification",
+        "Guardrails"
+      ],
+      "context_window": 32000,
+      "max_output": 4096,
+      "pricing": {
+        "input": 0.0,
+        "output": 0.0,
+        "cached_read": 0.0,
+        "cached_write": 0.0,
+        "unit": "per_1m_tokens"
+      },
+      "capabilities": [
+        "Documents"
+      ]
+    },
+    {
+      "id": "bolt-instruct-7b",
+      "name": "Bolt-Instruct-7B",
+      "model_type": "llm",
+      "type": "completion",
+      "tasks": [
+        "Text Generation",
+        "Routing",
+        "Orchestration"
+      ],
+      "context_window": 32000,
+      "max_output": 8192,
+      "pricing": {
+        "input": 0.0,
+        "output": 0.0,
+        "cached_read": 0.0,
+        "cached_write": 0.0,
+        "unit": "per_1m_tokens"
+      },
+      "capabilities": [
+        "Documents",
+        "Data analyst"
+      ]
+    },
+    {
+      "id": "bolt-instruct-32b",
+      "name": "Bolt-Instruct-32B",
+      "model_type": "llm",
+      "type": "completion",
+      "tasks": [
+        "Text Generation",
+        "Reasoning"
+      ],
+      "context_window": 128000,
+      "max_output": 16384,
+      "pricing": {
+        "input": 0.0,
+        "output": 0.0,
+        "cached_read": 0.0,
+        "cached_write": 0.0,
+        "unit": "per_1m_tokens"
+      },
+      "capabilities": [
+        "Documents",
+        "Data analyst"
+      ]
+    },
+    {
+      "id": "bolt-embedding-large",
+      "name": "Bolt-Embedding-Large",
+      "model_type": "embedding",
+      "type": "embedding",
+      "tasks": [
+        "Text Embeddings",
+        "Indexing",
+        "Retrieval"
+      ],
+      "context_window": 8192,
+      "max_output": null,
+      "pricing": {
+        "input": 0.0,
+        "output": null,
+        "cached_read": null,
+        "cached_write": null,
+        "unit": "per_1m_tokens"
+      },
+      "capabilities": [
+        "Documents"
+      ]
+    },
+    {
+      "id": "bolt-vision-9b",
+      "name": "Bolt-Vision-9B",
+      "model_type": "vision",
+      "type": "completion",
+      "tasks": [
+        "Image-to-Text",
+        "OCR",
+        "Document Parsing"
+      ],
+      "context_window": 32000,
+      "max_output": 8192,
+      "pricing": {
+        "input": 0.0,
+        "output": 0.0,
+        "cached_read": 0.0,
+        "cached_write": 0.0,
+        "unit": "per_1m_tokens"
+      },
+      "capabilities": [
+        "Documents",
+        "Image analysis"
+      ]
+    }
+  ]
+}

data/lib/multiwoven/integrations/source/aisquared/config/spec.json

@@ -6,7 +6,12 @@
     "$schema": "http://json-schema.org/draft-07/schema#",
     "title": "AI Squared Bolt",
     "type": "object",
-    "required": ["request_format", "response_format"],
+    "x-dynamic-input-path": "messages.0.content",
+    "x-output-path": "choices.0.message.content",
+    "required": [
+      "request_format",
+      "response_format"
+    ],
     "properties": {
       "request_format": {
         "title": "Request Format",

data/lib/multiwoven/integrations/source/anthropic/config/meta.json

@@ -1,16 +1,23 @@
 {
   "data": {
     "name": "Anthropic",
-    "title": "Anthropic Model Endpoint",
+    "title": "Anthropic",
     "connector_type": "source",
     "category": "AI Model",
     "sub_category": "LLM",
+    "provider_type": "third_party",
+    "display_order": 30,
+    "openrouter_slug": "anthropic",
+    "description": "Claude model family for nuanced reasoning, analysis, and generation. Strong safety alignment and instruction-following across all model sizes.",
     "documentation_url": "https://docs.squared.ai/activation/ai-ml-sources/anthropic-model",
     "github_issue_label": "source-anthropic-model",
     "icon": "icon.svg",
     "license": "MIT",
     "release_stage": "alpha",
     "support_level": "community",
-    "tags": ["language:ruby", "multiwoven"]
+    "tags": [
+      "language:ruby",
+      "multiwoven"
+    ]
   }
 }

data/lib/multiwoven/integrations/source/anthropic/config/models.json

@@ -0,0 +1,4 @@
+{
+  "//models": "Sourced live from OpenRouter via the openrouter_slug in meta.json. Do not hand-curate; add entries here only for models OpenRouter does not list.",
+  "models": []
+}