LLM-Driven Extraction of Unstructured Data — Built for API Deployments & ETL Pipeline Workflows
Python ai-agentsdata-engineeringdocument-aigenerative-aiidpjson-extractionllmmcp-serverocrpdf-extractionprompt-engineeringstructured-output
UN-3503 [FEAT] Add NVIDIA Build and OpenRouter OpenAI-compatible LLM and embedding adapters (#2004)
Chandrasekharan M971fdf513df9
diff --git a/frontend/public/icons/adapter-icons/NvidiaBuild.png b/frontend/public/icons/adapter-icons/NvidiaBuild.pngnew file mode 100644index 000000000..de449c13aBinary files /dev/null and b/frontend/public/icons/adapter-icons/NvidiaBuild.png differdiff --git a/frontend/public/icons/adapter-icons/OpenRouter.png b/frontend/public/icons/adapter-icons/OpenRouter.pngnew file mode 100644index 000000000..acaabd3daBinary files /dev/null and b/frontend/public/icons/adapter-icons/OpenRouter.png differdiff --git a/unstract/sdk1/src/unstract/sdk1/adapters/base1.py b/unstract/sdk1/src/unstract/sdk1/adapters/base1.pyindex da154f36a..ebd93e3db 100644--- a/unstract/sdk1/src/unstract/sdk1/adapters/base1.py+++ b/unstract/sdk1/src/unstract/sdk1/adapters/base1.py@@ -353,6 +353,9 @@ class OpenAILLMParameters(BaseChatCompletionParameters):_OPENAI_PROVIDER_PREFIX = "openai/"_CUSTOM_OPENAI_PROVIDER_PREFIX = "custom_openai/"_OPENAI_REASONING_MODEL_PATTERN = re.compile(r"^(o1|o3|o4|gpt-5)(?:[-/]|$)")+# Keyless gateways still need a non-empty key; the OpenAI SDK rejects a+# null/blank one before any request reaches the endpoint.+_NO_AUTH_API_KEY = "no-auth"def _is_openai_reasoning_model(model: str) -> bool:@@ -494,6 +497,86 @@ class OpenAICompatibleLLMParameters(BaseChatCompletionParameters):return f"{_CUSTOM_OPENAI_PROVIDER_PREFIX}{model}"+# Shared validation for branded adapters that reuse the OpenAI-compatible wire+# protocol with a fixed default endpoint.+def _validate_branded_openai_compatible(+ adapter_metadata: dict[str, "Any"], default_api_base: str+) -> dict[str, "Any"]:+ # Endpoint stays overridable so a provider URL change needs no release.+ api_base = adapter_metadata.get("api_base")+ if not (isinstance(api_base, str) and api_base.strip()):+ api_base = default_api_base+ adapter_metadata = {**adapter_metadata, "api_base": api_base}+ return OpenAICompatibleLLMParameters.validate(adapter_metadata)+++_NVIDIA_BUILD_API_BASE = "https://integrate.api.nvidia.com/v1"+_OPENROUTER_API_BASE = "https://openrouter.ai/api/v1"+_OPENROUTER_PROVIDER_PREFIX = "openrouter/"+++class NvidiaBuildLLMParameters(OpenAICompatibleLLMParameters):+ """OpenAI-compatible adapter for NVIDIA's hosted models (build.nvidia.com)."""++ # Required str so a directly-constructed instance stays valid.+ api_base: str = _NVIDIA_BUILD_API_BASE++ @staticmethod+ def validate(adapter_metadata: dict[str, "Any"]) -> dict[str, "Any"]:+ return _validate_branded_openai_compatible(+ adapter_metadata, _NVIDIA_BUILD_API_BASE+ )+++class OpenRouterLLMParameters(BaseChatCompletionParameters):+ """Adapter for OpenRouter (openrouter.ai).++ Routed through LiteLLM's native `openrouter/` provider so per-token costs+ resolve and reasoning params map without provider-specific workarounds.+ """++ api_key: str+ api_base: str = _OPENROUTER_API_BASE+ reasoning_effort: str | None = None++ @staticmethod+ def validate(adapter_metadata: dict[str, "Any"]) -> dict[str, "Any"]:+ adapter_metadata = dict(adapter_metadata)+ api_base = adapter_metadata.get("api_base")+ if not (isinstance(api_base, str) and api_base.strip()):+ adapter_metadata["api_base"] = _OPENROUTER_API_BASE+ adapter_metadata["model"] = OpenRouterLLMParameters.validate_model(+ adapter_metadata+ )+ # Reasoning models reject a non-default temperature; drop it and send+ # reasoning_effort only when reasoning is enabled. On a re-validation+ # pass `enable_reasoning` is absent (it isn't serialized), so recover the+ # state from a surviving reasoning_effort to keep reload idempotent —+ # unless the user explicitly opted out with `enable_reasoning: false`.+ enable_reasoning = adapter_metadata.get("enable_reasoning", False)+ if (+ not enable_reasoning+ and "enable_reasoning" not in adapter_metadata+ and adapter_metadata.get("reasoning_effort") is not None+ ):+ enable_reasoning = True+ adapter_metadata.pop("enable_reasoning", None)+ if enable_reasoning:+ adapter_metadata["temperature"] = None+ else:+ adapter_metadata.pop("reasoning_effort", None)+ return OpenRouterLLMParameters(**adapter_metadata).model_dump()++ @staticmethod+ def validate_model(adapter_metadata: dict[str, "Any"]) -> str:+ model = str(adapter_metadata.get("model", "")).strip()+ if not model:+ raise ValueError("model is required for the OpenRouter adapter.")+ if model.startswith(_OPENROUTER_PROVIDER_PREFIX):+ return model+ return f"{_OPENROUTER_PROVIDER_PREFIX}{model}"++class AzureOpenAILLMParameters(BaseChatCompletionParameters):"""See https://docs.litellm.ai/docs/providers/azure/#completion---using-azure_ad_token-api_base-api_version."""@@ -1296,6 +1379,8 @@ class OpenAIEmbeddingParameters(BaseEmbeddingParameters):api_base: str | None = Noneembed_batch_size: int | None = 10dimensions: int | None = None # For text-embedding-3-* models+ # Strict endpoints reject the null LiteLLM sends when this is unset.+ encoding_format: str | None = None@staticmethoddef validate(adapter_metadata: dict[str, "Any"]) -> dict[str, "Any"]:@@ -1311,6 +1396,77 @@ class OpenAIEmbeddingParameters(BaseEmbeddingParameters):return model+# custom_openai has no embedding support, so these route through LiteLLM's+# native nvidia_nim provider; its default api_base is pinned for the schema.+_NVIDIA_NIM_PROVIDER_PREFIX = "nvidia_nim/"+++class NvidiaBuildEmbeddingParameters(OpenAIEmbeddingParameters):+ """OpenAI-compatible embeddings via NVIDIA's hosted endpoint (build.nvidia.com)."""++ # Overridable default endpoint.+ api_base: str = _NVIDIA_BUILD_API_BASE++ @staticmethod+ def validate(adapter_metadata: dict[str, "Any"]) -> dict[str, "Any"]:+ adapter_metadata = dict(adapter_metadata)+ # Endpoint stays overridable so a provider URL change needs no release.+ api_base = adapter_metadata.get("api_base")+ if not (isinstance(api_base, str) and api_base.strip()):+ adapter_metadata["api_base"] = _NVIDIA_BUILD_API_BASE+ # Strict endpoints reject the null LiteLLM sends; pin a real value.+ adapter_metadata.setdefault("encoding_format", "float")+ adapter_metadata["model"] = NvidiaBuildEmbeddingParameters.validate_model(+ adapter_metadata+ )+ return OpenAIEmbeddingParameters(**adapter_metadata).model_dump()++ @staticmethod+ def validate_model(adapter_metadata: dict[str, "Any"]) -> str:+ model = str(adapter_metadata.get("model", "")).strip()+ if not model:+ raise ValueError("model is required for the NVIDIA Build embedding adapter.")+ if model.startswith(_NVIDIA_NIM_PROVIDER_PREFIX):+ return model+ return f"{_NVIDIA_NIM_PROVIDER_PREFIX}{model}"+++class OpenAICompatibleEmbeddingParameters(OpenAIEmbeddingParameters):+ """Embeddings for any OpenAI-compatible server (vLLM, self-hosted, etc.).++ Routes through the `openai/` provider with a user-supplied `api_base`;+ cost stays unresolved since the endpoint is arbitrary.+ """++ # Some gateways are keyless; the endpoint is always required.+ api_key: str | None = None+ api_base: str++ @staticmethod+ def validate(adapter_metadata: dict[str, "Any"]) -> dict[str, "Any"]:+ adapter_metadata = dict(adapter_metadata)+ api_key = adapter_metadata.get("api_key")+ if not (isinstance(api_key, str) and api_key.strip()):+ adapter_metadata["api_key"] = _NO_AUTH_API_KEY+ # Strict endpoints reject the null LiteLLM sends; pin a real value.+ adapter_metadata.setdefault("encoding_format", "float")+ adapter_metadata["model"] = OpenAICompatibleEmbeddingParameters.validate_model(+ adapter_metadata+ )+ return OpenAICompatibleEmbeddingParameters(**adapter_metadata).model_dump()++ @staticmethod+ def validate_model(adapter_metadata: dict[str, "Any"]) -> str:+ model = str(adapter_metadata.get("model", "")).strip()+ if not model:+ raise ValueError(+ "model is required for the OpenAI Compatible embedding adapter."+ )+ if model.startswith(_OPENAI_PROVIDER_PREFIX):+ return model+ return f"{_OPENAI_PROVIDER_PREFIX}{model}"++class AzureOpenAIEmbeddingParameters(BaseEmbeddingParameters):"""See https://docs.litellm.ai/docs/providers/azure."""diff --git a/unstract/sdk1/src/unstract/sdk1/adapters/embedding1/__init__.py b/unstract/sdk1/src/unstract/sdk1/adapters/embedding1/__init__.pyindex 3f7de6e91..18f240f04 100644--- a/unstract/sdk1/src/unstract/sdk1/adapters/embedding1/__init__.py+++ b/unstract/sdk1/src/unstract/sdk1/adapters/embedding1/__init__.py@@ -4,8 +4,12 @@ from unstract.sdk1.adapters.base1 import register_adaptersfrom unstract.sdk1.adapters.embedding1.azure_openai import AzureOpenAIEmbeddingAdapterfrom unstract.sdk1.adapters.embedding1.bedrock import AWSBedrockEmbeddingAdapterfrom unstract.sdk1.adapters.embedding1.gemini import GeminiEmbeddingAdapter+from unstract.sdk1.adapters.embedding1.nvidia_build import NvidiaBuildEmbeddingAdapterfrom unstract.sdk1.adapters.embedding1.ollama import OllamaEmbeddingAdapterfrom unstract.sdk1.adapters.embedding1.openai import OpenAIEmbeddingAdapter+from unstract.sdk1.adapters.embedding1.openai_compatible import (+ OpenAICompatibleEmbeddingAdapter,+)from unstract.sdk1.adapters.embedding1.vertexai import VertexAIEmbeddingAdapterfrom unstract.sdk1.adapters.enums import AdapterTypes@@ -18,7 +22,9 @@ __all__ = ["AzureOpenAIEmbeddingAdapter","AWSBedrockEmbeddingAdapter","GeminiEmbeddingAdapter",+ "NvidiaBuildEmbeddingAdapter","OpenAIEmbeddingAdapter",+ "OpenAICompatibleEmbeddingAdapter","VertexAIEmbeddingAdapter","OllamaEmbeddingAdapter",]diff --git a/unstract/sdk1/src/unstract/sdk1/adapters/embedding1/nvidia_build.py b/unstract/sdk1/src/unstract/sdk1/adapters/embedding1/nvidia_build.pynew file mode 100644index 000000000..d65d57ac5--- /dev/null+++ b/unstract/sdk1/src/unstract/sdk1/adapters/embedding1/nvidia_build.py@@ -0,0 +1,45 @@+from typing import Any++from unstract.sdk1.adapters.base1 import BaseAdapter, NvidiaBuildEmbeddingParameters+from unstract.sdk1.adapters.enums import AdapterTypes++DESCRIPTION = (+ "Adapter for NVIDIA's OpenAI-compatible embedding models (build.nvidia.com). "+ "Supply a model name and your NVIDIA API key; the endpoint is preconfigured."+)+++class NvidiaBuildEmbeddingAdapter(NvidiaBuildEmbeddingParameters, BaseAdapter):+ @staticmethod+ def get_id() -> str:+ return "nvidiabuild|2afcdf59-5323-4086-97fb-d9a0432e7795"++ @staticmethod+ def get_metadata() -> dict[str, Any]:+ return {+ "name": "NVIDIA Build",+ "version": "1.0.0",+ "adapter": NvidiaBuildEmbeddingAdapter,+ "description": DESCRIPTION,+ "is_active": True,+ }++ @staticmethod+ def get_name() -> str:+ return "NVIDIA Build"++ @staticmethod+ def get_description() -> str:+ return DESCRIPTION++ @staticmethod+ def get_provider() -> str:+ return "nvidia_build"++ @staticmethod+ def get_icon() -> str:+ return "/icons/adapter-icons/NvidiaBuild.png"++ @staticmethod+ def get_adapter_type() -> AdapterTypes:+ return AdapterTypes.EMBEDDINGdiff --git a/unstract/sdk1/src/unstract/sdk1/adapters/embedding1/openai_compatible.py b/unstract/sdk1/src/unstract/sdk1/adapters/embedding1/openai_compatible.pynew file mode 100644index 000000000..12fb1f2f6--- /dev/null+++ b/unstract/sdk1/src/unstract/sdk1/adapters/embedding1/openai_compatible.py@@ -0,0 +1,49 @@+from typing import Any++from unstract.sdk1.adapters.base1 import (+ BaseAdapter,+ OpenAICompatibleEmbeddingParameters,+)+from unstract.sdk1.adapters.enums import AdapterTypes++DESCRIPTION = (+ "Embedding adapter for servers that implement the OpenAI Embeddings API "+ "(vLLM, self-hosted gateways, and third-party providers). "+ "Use OpenAI for the official OpenAI service."+)+++class OpenAICompatibleEmbeddingAdapter(OpenAICompatibleEmbeddingParameters, BaseAdapter):+ @staticmethod+ def get_id() -> str:+ return "openaicompatible|65573de7-2ea5-4631-bb49-492717972455"++ @staticmethod+ def get_metadata() -> dict[str, Any]:+ return {+ "name": "OpenAI Compatible",+ "version": "1.0.0",+ "adapter": OpenAICompatibleEmbeddingAdapter,+ "description": DESCRIPTION,+ "is_active": True,+ }++ @staticmethod+ def get_name() -> str:+ return "OpenAI Compatible"++ @staticmethod+ def get_description() -> str:+ return DESCRIPTION++ @staticmethod+ def get_provider() -> str:+ return "custom_openai"++ @staticmethod+ def get_icon() -> str:+ return "/icons/adapter-icons/OpenAICompatible.png"++ @staticmethod+ def get_adapter_type() -> AdapterTypes:+ return AdapterTypes.EMBEDDINGdiff --git a/unstract/sdk1/src/unstract/sdk1/adapters/embedding1/static/azure.json b/unstract/sdk1/src/unstract/sdk1/adapters/embedding1/static/azure.jsonindex f1ca8d223..b080a3d2f 100644--- a/unstract/sdk1/src/unstract/sdk1/adapters/embedding1/static/azure.json+++ b/unstract/sdk1/src/unstract/sdk1/adapters/embedding1/static/azure.json@@ -54,13 +54,6 @@"title": "Dimensions","description": "Output embedding dimensions. Only supported by text-embedding-3-* models. Leave empty for default dimensions."},- "embed_batch_size": {- "type": "number",- "minimum": 0,- "multipleOf": 1,- "title": "Embedding Batch Size",- "default": 5- },"max_retries": {"type": "number","minimum": 0,diff --git a/unstract/sdk1/src/unstract/sdk1/adapters/embedding1/static/custom_openai.json b/unstract/sdk1/src/unstract/sdk1/adapters/embedding1/static/custom_openai.jsonnew file mode 100644index 000000000..bde166522--- /dev/null+++ b/unstract/sdk1/src/unstract/sdk1/adapters/embedding1/static/custom_openai.json@@ -0,0 +1,53 @@+{+ "title": "OpenAI Compatible Embedding",+ "type": "object",+ "required": [+ "adapter_name",+ "model",+ "api_base"+ ],+ "properties": {+ "adapter_name": {+ "type": "string",+ "title": "Name",+ "default": "",+ "description": "Provide a unique name for this adapter instance. Example: compatible-emb-1"+ },+ "model": {+ "type": "string",+ "title": "Model",+ "description": "The embedding model name expected by your OpenAI-compatible endpoint. Examples: text-embedding-3-small, BAAI/bge-m3, nomic-embed-text"+ },+ "api_key": {+ "type": [+ "string",+ "null"+ ],+ "title": "API Key",+ "format": "password",+ "description": "API key for your OpenAI-compatible endpoint. Leave empty if the endpoint does not require one."+ },+ "api_base": {+ "type": "string",+ "format": "uri",+ "title": "API Base",+ "description": "Base URL for the OpenAI-compatible embeddings endpoint. Examples: https://gateway.example.com/v1, https://llm.example.net/openai/v1"+ },+ "max_retries": {+ "type": "number",+ "minimum": 0,+ "multipleOf": 1,+ "title": "Max Retries",+ "default": 3,+ "description": "The maximum number of times to retry a request if it fails."+ },+ "timeout": {+ "type": "number",+ "minimum": 0,+ "multipleOf": 1,+ "title": "Timeout",+ "default": 240,+ "description": "Timeout in seconds"+ }+ }+}diff --git a/unstract/sdk1/src/unstract/sdk1/adapters/embedding1/static/gemini.json b/unstract/sdk1/src/unstract/sdk1/adapters/embedding1/static/gemini.jsonindex e614867eb..5a5096716 100644--- a/unstract/sdk1/src/unstract/sdk1/adapters/embedding1/static/gemini.json+++ b/unstract/sdk1/src/unstract/sdk1/adapters/embedding1/static/gemini.json@@ -25,13 +25,6 @@"default": "","format": "password"},- "embed_batch_size": {- "type": "number",- "minimum": 1,- "multipleOf": 1,- "title": "Embed Batch Size",- "description": "Number of texts to embed in a single batch. Leave empty to use the system default."- },"timeout": {"type": "number","minimum": 0,diff --git a/unstract/sdk1/src/unstract/sdk1/adapters/embedding1/static/nvidia_build.json b/unstract/sdk1/src/unstract/sdk1/adapters/embedding1/static/nvidia_build.jsonnew file mode 100644index 000000000..fa2b14247--- /dev/null+++ b/unstract/sdk1/src/unstract/sdk1/adapters/embedding1/static/nvidia_build.json@@ -0,0 +1,51 @@+{+ "title": "NVIDIA Build Embedding",+ "type": "object",+ "required": [+ "adapter_name",+ "api_key",+ "model"+ ],+ "properties": {+ "adapter_name": {+ "type": "string",+ "title": "Name",+ "default": "",+ "description": "Provide a unique name for this adapter instance. Example: nvidia-build-emb-1"+ },+ "model": {+ "type": "string",+ "title": "Model",+ "description": "The embedding model name as listed on [build.nvidia.com/models](https://build.nvidia.com/models). Examples: nvidia/nv-embedqa-e5-v5, nvidia/llama-3.2-nv-embedqa-1b-v2"+ },+ "api_key": {+ "type": "string",+ "title": "API Key",+ "format": "password",+ "description": "Your NVIDIA API key from [build.nvidia.com](https://build.nvidia.com)."+ },+ "api_base": {+ "type": "string",+ "format": "uri",+ "title": "API Base",+ "default": "https://integrate.api.nvidia.com/v1",+ "description": "NVIDIA Build endpoint. Pre-filled with the default; change only if NVIDIA moves the base URL."+ },+ "max_retries": {+ "type": "number",+ "minimum": 0,+ "multipleOf": 1,+ "title": "Max Retries",+ "default": 3,+ "description": "The maximum number of times to retry a request if it fails."+ },+ "timeout": {+ "type": "number",+ "minimum": 0,+ "multipleOf": 1,+ "title": "Timeout",+ "default": 240,+ "description": "Timeout in seconds"+ }+ }+}diff --git a/unstract/sdk1/src/unstract/sdk1/adapters/embedding1/static/ollama.json b/unstract/sdk1/src/unstract/sdk1/adapters/embedding1/static/ollama.jsonindex 8dd9bfa1c..c241e5e71 100644--- a/unstract/sdk1/src/unstract/sdk1/adapters/embedding1/static/ollama.json+++ b/unstract/sdk1/src/unstract/sdk1/adapters/embedding1/static/ollama.json@@ -25,13 +25,6 @@"default": "","description": "Provide the base URL where Ollama server is running. Example: `http://docker.host.internal:11434` or `http://localhost:11434`"},- "embed_batch_size": {- "type": "number",- "minimum": 0,- "multipleOf": 1,- "title": "Embed Batch Size",- "default": 10- },"max_retries": {"type": "number","minimum": 0,diff --git a/unstract/sdk1/src/unstract/sdk1/adapters/embedding1/static/openai.json b/unstract/sdk1/src/unstract/sdk1/adapters/embedding1/static/openai.jsonindex 3ad21d356..30e272403 100644--- a/unstract/sdk1/src/unstract/sdk1/adapters/embedding1/static/openai.json+++ b/unstract/sdk1/src/unstract/sdk1/adapters/embedding1/static/openai.json@@ -37,13 +37,6 @@"title": "Dimensions","description": "Output embedding dimensions. Only supported by text-embedding-3-* models. Leave empty for default dimensions (1536 for small, 3072 for large)."},- "embed_batch_size": {- "type": "number",- "minimum": 0,- "multipleOf": 1,- "title": "Embed Batch Size",- "default": 10- },"max_retries": {"type": "number","minimum": 0,diff --git a/unstract/sdk1/src/unstract/sdk1/adapters/embedding1/static/vertexai.json b/unstract/sdk1/src/unstract/sdk1/adapters/embedding1/static/vertexai.jsonindex 6aa48e883..5dec85462 100644--- a/unstract/sdk1/src/unstract/sdk1/adapters/embedding1/static/vertexai.json+++ b/unstract/sdk1/src/unstract/sdk1/adapters/embedding1/static/vertexai.json@@ -38,13 +38,6 @@"default": "global","description": "The Google Cloud region for the Vertex AI endpoint (e.g., us-central1, global). If left empty, defaults to us-central1."},- "embed_batch_size": {- "type": "number",- "minimum": 0,- "multipleOf": 1,- "title": "Embedding Batch Size",- "default": 10- },"embed_mode": {"type": "string","title": "Embed Mode",diff --git a/unstract/sdk1/src/unstract/sdk1/adapters/llm1/__init__.py b/unstract/sdk1/src/unstract/sdk1/adapters/llm1/__init__.pyindex 1da3590f5..2d935e218 100644--- a/unstract/sdk1/src/unstract/sdk1/adapters/llm1/__init__.py+++ b/unstract/sdk1/src/unstract/sdk1/adapters/llm1/__init__.py@@ -6,9 +6,11 @@ from unstract.sdk1.adapters.llm1.anthropic import AnthropicLLMAdapterfrom unstract.sdk1.adapters.llm1.anyscale import AnyscaleLLMAdapterfrom unstract.sdk1.adapters.llm1.azure_openai import AzureOpenAILLMAdapterfrom unstract.sdk1.adapters.llm1.bedrock import AWSBedrockLLMAdapter+from unstract.sdk1.adapters.llm1.nvidia_build import NvidiaBuildLLMAdapterfrom unstract.sdk1.adapters.llm1.ollama import OllamaLLMAdapterfrom unstract.sdk1.adapters.llm1.openai import OpenAILLMAdapterfrom unstract.sdk1.adapters.llm1.openai_compatible import OpenAICompatibleLLMAdapter+from unstract.sdk1.adapters.llm1.openrouter import OpenRouterLLMAdapterfrom unstract.sdk1.adapters.llm1.vertexai import VertexAILLMAdapteradapters: dict[str, dict[str, Any]] = {}@@ -21,8 +23,10 @@ __all__ = ["AnyscaleLLMAdapter","AWSBedrockLLMAdapter","AzureOpenAILLMAdapter",+ "NvidiaBuildLLMAdapter","OllamaLLMAdapter","OpenAILLMAdapter","OpenAICompatibleLLMAdapter",+ "OpenRouterLLMAdapter","VertexAILLMAdapter",]diff --git a/unstract/sdk1/src/unstract/sdk1/adapters/llm1/nvidia_build.py b/unstract/sdk1/src/unstract/sdk1/adapters/llm1/nvidia_build.pynew file mode 100644index 000000000..f601a9d53--- /dev/null+++ b/unstract/sdk1/src/unstract/sdk1/adapters/llm1/nvidia_build.py@@ -0,0 +1,45 @@+from typing import Any++from unstract.sdk1.adapters.base1 import BaseAdapter, NvidiaBuildLLMParameters+from unstract.sdk1.adapters.enums import AdapterTypes++DESCRIPTION = (+ "Adapter for NVIDIA's OpenAI-compatible hosted models (build.nvidia.com). "+ "Supply a model name and your NVIDIA API key; the endpoint is preconfigured."+)+++class NvidiaBuildLLMAdapter(NvidiaBuildLLMParameters, BaseAdapter):+ @staticmethod+ def get_id() -> str:+ return "nvidiabuild|240d142d-68dd-4b6f-9716-80afd5c661cc"++ @staticmethod+ def get_metadata() -> dict[str, Any]:+ return {+ "name": "NVIDIA Build",+ "version": "1.0.0",+ "adapter": NvidiaBuildLLMAdapter,+ "description": DESCRIPTION,+ "is_active": True,+ }++ @staticmethod+ def get_name() -> str:+ return "NVIDIA Build"++ @staticmethod+ def get_description() -> str:+ return DESCRIPTION++ @staticmethod+ def get_provider() -> str:+ return "nvidia_build"++ @staticmethod+ def get_icon() -> str:+ return "/icons/adapter-icons/NvidiaBuild.png"++ @staticmethod+ def get_adapter_type() -> AdapterTypes:+ return AdapterTypes.LLMdiff --git a/unstract/sdk1/src/unstract/sdk1/adapters/llm1/openrouter.py b/unstract/sdk1/src/unstract/sdk1/adapters/llm1/openrouter.pynew file mode 100644index 000000000..9ed260ed8--- /dev/null+++ b/unstract/sdk1/src/unstract/sdk1/adapters/llm1/openrouter.py@@ -0,0 +1,45 @@+from typing import Any++from unstract.sdk1.adapters.base1 import BaseAdapter, OpenRouterLLMParameters+from unstract.sdk1.adapters.enums import AdapterTypes++DESCRIPTION = (+ "Adapter for OpenRouter's OpenAI-compatible API (openrouter.ai). "+ "Supply a model name and your OpenRouter API key; the endpoint is preconfigured."+)+++class OpenRouterLLMAdapter(OpenRouterLLMParameters, BaseAdapter):+ @staticmethod+ def get_id() -> str:+ return "openrouter|17756452-5dca-4e10-9cbf-d9bc16505458"++ @staticmethod+ def get_metadata() -> dict[str, Any]:+ return {+ "name": "OpenRouter",+ "version": "1.0.0",+ "adapter": OpenRouterLLMAdapter,+ "description": DESCRIPTION,+ "is_active": True,+ }++ @staticmethod+ def get_name() -> str:+ return "OpenRouter"++ @staticmethod+ def get_description() -> str:+ return DESCRIPTION++ @staticmethod+ def get_provider() -> str:+ return "openrouter"++ @staticmethod+ def get_icon() -> str:+ return "/icons/adapter-icons/OpenRouter.png"++ @staticmethod+ def get_adapter_type() -> AdapterTypes:+ return AdapterTypes.LLMdiff --git a/unstract/sdk1/src/unstract/sdk1/adapters/llm1/static/nvidia_build.json b/unstract/sdk1/src/unstract/sdk1/adapters/llm1/static/nvidia_build.jsonnew file mode 100644index 000000000..2277516f2--- /dev/null+++ b/unstract/sdk1/src/unstract/sdk1/adapters/llm1/static/nvidia_build.json@@ -0,0 +1,112 @@+{+ "title": "NVIDIA Build",+ "type": "object",+ "required": [+ "adapter_name",+ "api_key",+ "model"+ ],+ "properties": {+ "adapter_name": {+ "type": "string",+ "title": "Name",+ "default": "",+ "description": "Provide a unique name for this adapter instance. Example: nvidia-build-1"+ },+ "api_key": {+ "type": "string",+ "title": "API Key",+ "format": "password",+ "description": "Your NVIDIA API key from [build.nvidia.com](https://build.nvidia.com)."+ },+ "model": {+ "type": "string",+ "title": "Model",+ "description": "The model name as listed on [build.nvidia.com/models](https://build.nvidia.com/models). Examples: nvidia/nemotron-mini-4b-instruct, meta/llama-3.1-70b-instruct"+ },+ "api_base": {+ "type": "string",+ "format": "url",+ "title": "API Base",+ "default": "https://integrate.api.nvidia.com/v1",+ "description": "NVIDIA Build endpoint. Pre-filled with the default; change only if NVIDIA moves the base URL."+ },+ "max_tokens": {+ "type": "number",+ "minimum": 0,+ "multipleOf": 1,+ "title": "Maximum Output Tokens",+ "default": 4096,+ "description": "Maximum number of output tokens to limit LLM replies. Leave it empty to use the provider default. Sent as `max_completion_tokens` when Enable Reasoning is on."+ },+ "max_retries": {+ "type": "number",+ "minimum": 0,+ "multipleOf": 1,+ "title": "Max Retries",+ "default": 5,+ "description": "The maximum number of times to retry a request if it fails."+ },+ "timeout": {+ "type": "number",+ "minimum": 0,+ "multipleOf": 1,+ "title": "Timeout",+ "default": 900,+ "description": "Timeout in seconds."+ },+ "enable_reasoning": {+ "type": "boolean",+ "title": "Enable Reasoning",+ "default": false,+ "description": "Toggle on for reasoning models to drop `temperature` and send `max_completion_tokens` and `reasoning_effort` via `extra_body` so the upstream API accepts them."+ }+ },+ "allOf": [+ {+ "if": {+ "properties": {+ "enable_reasoning": {+ "const": true+ }+ },+ "required": [+ "enable_reasoning"+ ]+ },+ "then": {+ "properties": {+ "reasoning_effort": {+ "type": "string",+ "enum": [+ "low",+ "medium",+ "high"+ ],+ "default": "medium",+ "title": "Reasoning Effort",+ "description": "Sets the reasoning strength when Enable Reasoning is on."+ }+ },+ "required": [+ "reasoning_effort"+ ]+ }+ },+ {+ "if": {+ "properties": {+ "enable_reasoning": {+ "const": false+ }+ },+ "required": [+ "enable_reasoning"+ ]+ },+ "then": {+ "properties": {}+ }+ }+ ]+}diff --git a/unstract/sdk1/src/unstract/sdk1/adapters/llm1/static/openrouter.json b/unstract/sdk1/src/unstract/sdk1/adapters/llm1/static/openrouter.jsonnew file mode 100644index 000000000..a7eede115--- /dev/null+++ b/unstract/sdk1/src/unstract/sdk1/adapters/llm1/static/openrouter.json@@ -0,0 +1,112 @@+{+ "title": "OpenRouter",+ "type": "object",+ "required": [+ "adapter_name",+ "api_key",+ "model"+ ],+ "properties": {+ "adapter_name": {+ "type": "string",+ "title": "Name",+ "default": "",+ "description": "Provide a unique name for this adapter instance. Example: openrouter-1"+ },+ "api_key": {+ "type": "string",+ "title": "API Key",+ "format": "password",+ "description": "Your OpenRouter API key from [openrouter.ai/keys](https://openrouter.ai/keys)."+ },+ "model": {+ "type": "string",+ "title": "Model",+ "description": "The model slug as listed on [openrouter.ai/models](https://openrouter.ai/models). Examples: openai/gpt-4o, anthropic/claude-3.5-sonnet, meta-llama/llama-3.1-70b-instruct"+ },+ "api_base": {+ "type": "string",+ "format": "url",+ "title": "API Base",+ "default": "https://openrouter.ai/api/v1",+ "description": "OpenRouter endpoint. Pre-filled with the default; change only if OpenRouter moves the base URL."+ },+ "max_tokens": {+ "type": "number",+ "minimum": 0,+ "multipleOf": 1,+ "title": "Maximum Output Tokens",+ "default": 4096,+ "description": "Maximum number of output tokens to limit LLM replies. Leave it empty to use the provider default."+ },+ "max_retries": {+ "type": "number",+ "minimum": 0,+ "multipleOf": 1,+ "title": "Max Retries",+ "default": 5,+ "description": "The maximum number of times to retry a request if it fails."+ },+ "timeout": {+ "type": "number",+ "minimum": 0,+ "multipleOf": 1,+ "title": "Timeout",+ "default": 900,+ "description": "Timeout in seconds."+ },+ "enable_reasoning": {+ "type": "boolean",+ "title": "Enable Reasoning",+ "default": false,+ "description": "Toggle on for reasoning models to send `reasoning_effort` to OpenRouter. See [OpenRouter reasoning docs](https://openrouter.ai/docs/use-cases/reasoning-tokens)."+ }+ },+ "allOf": [+ {+ "if": {+ "properties": {+ "enable_reasoning": {+ "const": true+ }+ },+ "required": [+ "enable_reasoning"+ ]+ },+ "then": {+ "properties": {+ "reasoning_effort": {+ "type": "string",+ "enum": [+ "low",+ "medium",+ "high"+ ],+ "default": "medium",+ "title": "Reasoning Effort",+ "description": "Sets the reasoning strength when Enable Reasoning is on."+ }+ },+ "required": [+ "reasoning_effort"+ ]+ }+ },+ {+ "if": {+ "properties": {+ "enable_reasoning": {+ "const": false+ }+ },+ "required": [+ "enable_reasoning"+ ]+ },+ "then": {+ "properties": {}+ }+ }+ ]+}diff --git a/unstract/sdk1/src/unstract/sdk1/embedding.py b/unstract/sdk1/src/unstract/sdk1/embedding.pyindex 109f2cd6a..1e02944f8 100644--- a/unstract/sdk1/src/unstract/sdk1/embedding.py+++ b/unstract/sdk1/src/unstract/sdk1/embedding.py@@ -29,6 +29,10 @@ logger = logging.getLogger(__name__)litellm.drop_params = True+# Asymmetric embedding models need an input_type (query|passage); other+# providers reject the field, so it's sent only for this prefix.+_NVIDIA_NIM_MODEL_PREFIX = "nvidia_nim/"+class Embedding:"""Unified embedding interface powered by LiteLLM.@@ -103,6 +107,8 @@ class Embedding:self.platform_kwargs: dict[str, object] = kwargsself.kwargs: dict[str, object] = self.adapter.validate(self._adapter_metadata)self._cost_model: str | None = self.kwargs.pop("cost_model", None)+ # Client-side batching hint, not an API field — keep it off the wire.+ self.kwargs.pop("embed_batch_size", None)except (ValidationError, ValueError) as e:raise SdkError("Invalid embedding adapter metadata: " + str(e)) from e@@ -119,13 +125,19 @@ class Embedding:return f"{self._adapter_name} ({name})"return name- def get_embedding(self, text: str) -> list[float]:+ def _prepare_call(self, input_type: str | None) -> tuple[str, dict, int | None]:+ """Split model/retries out of kwargs and inject input_type when applicable."""+ kwargs = self.kwargs.copy()+ model = kwargs.pop("model")+ max_retries = pop_litellm_retry_kwargs(kwargs, self._get_adapter_info())+ if input_type and str(model).startswith(_NVIDIA_NIM_MODEL_PREFIX):+ kwargs["input_type"] = input_type+ return model, kwargs, max_retries++ def get_embedding(self, text: str, input_type: str = "query") -> list[float]:"""Return embedding vector for query string."""try:- kwargs = self.kwargs.copy()- model = kwargs.pop("model")- max_retries = pop_litellm_retry_kwargs(kwargs, self._get_adapter_info())-+ model, kwargs, max_retries = self._prepare_call(input_type)resp = call_with_retry(lambda: litellm.embedding(model=model, input=[text], **kwargs),max_retries=max_retries,@@ -136,13 +148,12 @@ class Embedding:except Exception as e:raise parse_litellm_err(e, self._get_adapter_info()) from e- def get_embeddings(self, texts: list[str]) -> list[list[float]]:+ def get_embeddings(+ self, texts: list[str], input_type: str = "passage"+ ) -> list[list[float]]:"""Return embedding vectors for list of query strings."""try:- kwargs = self.kwargs.copy()- model = kwargs.pop("model")- max_retries = pop_litellm_retry_kwargs(kwargs, self._get_adapter_info())-+ model, kwargs, max_retries = self._prepare_call(input_type)resp = call_with_retry(lambda: litellm.embedding(model=model, input=texts, **kwargs),max_retries=max_retries,@@ -153,13 +164,10 @@ class Embedding:except Exception as e:raise parse_litellm_err(e, self._get_adapter_info()) from e- async def get_aembedding(self, text: str) -> list[float]:+ async def get_aembedding(self, text: str, input_type: str = "query") -> list[float]:"""Return async embedding vector for query string."""try:- kwargs = self.kwargs.copy()- model = kwargs.pop("model")- max_retries = pop_litellm_retry_kwargs(kwargs, self._get_adapter_info())-+ model, kwargs, max_retries = self._prepare_call(input_type)resp = await acall_with_retry(lambda: litellm.aembedding(model=model, input=[text], **kwargs),max_retries=max_retries,@@ -170,13 +178,12 @@ class Embedding:except Exception as e:raise parse_litellm_err(e, self._get_adapter_info()) from e- async def get_aembeddings(self, texts: list[str]) -> list[list[float]]:+ async def get_aembeddings(+ self, texts: list[str], input_type: str = "passage"+ ) -> list[list[float]]:"""Return async embedding vectors for list of query strings."""try:- kwargs = self.kwargs.copy()- model = kwargs.pop("model")- max_retries = pop_litellm_retry_kwargs(kwargs, self._get_adapter_info())-+ model, kwargs, max_retries = self._prepare_call(input_type)resp = await acall_with_retry(lambda: litellm.aembedding(model=model, input=texts, **kwargs),max_retries=max_retries,@@ -256,25 +263,25 @@ class EmbeddingCompat(BaseEmbedding):)def _get_query_embedding(self, query: str) -> list[float]:- return self._embedding_instance.get_embedding(query)+ return self._embedding_instance.get_embedding(query, input_type="query")def _get_text_embedding(self, text: str) -> list[float]:- return self._embedding_instance.get_embedding(text)+ return self._embedding_instance.get_embedding(text, input_type="passage")def _get_text_embeddings(self, texts: list[str]) -> list[list[float]]:- return self._embedding_instance.get_embeddings(texts)+ return self._embedding_instance.get_embeddings(texts, input_type="passage")def get_query_embedding(self, query: str) -> list[float]:return self._get_query_embedding(query)async def _aget_query_embedding(self, query: str) -> list[float]:- return await self._embedding_instance.get_aembedding(query)+ return await self._embedding_instance.get_aembedding(query, input_type="query")async def _aget_text_embedding(self, text: str) -> list[float]:- return await self._embedding_instance.get_aembedding(text)+ return await self._embedding_instance.get_aembedding(text, input_type="passage")async def _aget_text_embeddings(self, texts: list[str]) -> list[list[float]]:- return await self._embedding_instance.get_aembeddings(texts)+ return await self._embedding_instance.get_aembeddings(texts, input_type="passage")async def get_aquery_embedding(self, query: str) -> list[float]:return await self._aget_query_embedding(query)diff --git a/unstract/sdk1/tests/test_branded_openai_adapters.py b/unstract/sdk1/tests/test_branded_openai_adapters.pynew file mode 100644index 000000000..c87669884--- /dev/null+++ b/unstract/sdk1/tests/test_branded_openai_adapters.py@@ -0,0 +1,311 @@+import json++import pytest+from unstract.sdk1.adapters.base1 import (+ NvidiaBuildEmbeddingParameters,+ NvidiaBuildLLMParameters,+ OpenAICompatibleEmbeddingParameters,+ OpenRouterLLMParameters,+)+from unstract.sdk1.adapters.constants import Common+from unstract.sdk1.adapters.embedding1 import adapters as embedding_adapters+from unstract.sdk1.adapters.embedding1.nvidia_build import NvidiaBuildEmbeddingAdapter+from unstract.sdk1.adapters.embedding1.openai_compatible import (+ OpenAICompatibleEmbeddingAdapter,+)+from unstract.sdk1.adapters.llm1 import adapters as llm_adapters+from unstract.sdk1.adapters.llm1.nvidia_build import NvidiaBuildLLMAdapter+from unstract.sdk1.adapters.llm1.openrouter import OpenRouterLLMAdapter++_NVIDIA_BUILD_API_BASE = "https://integrate.api.nvidia.com/v1"+_OPENROUTER_API_BASE = "https://openrouter.ai/api/v1"+++# --- Branded LLM adapters -------------------------------------------------+++ "adapter",+ [NvidiaBuildLLMAdapter, OpenRouterLLMAdapter],+)+def test_branded_llm_adapter_is_registered(adapter: type) -> None:+ adapter_id = adapter.get_id()+ assert adapter_id in llm_adapters+ assert llm_adapters[adapter_id][Common.MODULE] is adapter+++def test_nvidia_llm_prefixes_model_via_custom_openai() -> None:+ validated = NvidiaBuildLLMParameters.validate({"model": "some-model", "api_key": "k"})++ assert validated["model"] == "custom_openai/some-model"+ assert validated["api_base"] == _NVIDIA_BUILD_API_BASE+++def test_openrouter_llm_routes_via_native_openrouter_provider() -> None:+ from litellm import get_llm_provider++ validated = OpenRouterLLMParameters.validate(+ {"model": "openai/gpt-4o", "api_key": "k"}+ )++ assert validated["model"] == "openrouter/openai/gpt-4o"+ assert validated["api_base"] == _OPENROUTER_API_BASE+ # Native routing is what lets LiteLLM resolve OpenRouter pricing.+ assert get_llm_provider(validated["model"])[1] == "openrouter"+++def test_openrouter_model_prefix_is_idempotent() -> None:+ once = OpenRouterLLMParameters.validate({"model": "openai/gpt-4o", "api_key": "k"})+ twice = OpenRouterLLMParameters.validate(dict(once))++ assert twice["model"] == once["model"] == "openrouter/openai/gpt-4o"+++def test_openrouter_forwards_reasoning_effort_only_when_enabled() -> None:+ on = OpenRouterLLMParameters.validate(+ {+ "model": "openai/gpt-5",+ "api_key": "k",+ "enable_reasoning": True,+ "reasoning_effort": "high",+ }+ )+ assert on["reasoning_effort"] == "high"+ # enable_reasoning is a UI-only toggle and must not leak to LiteLLM.+ assert "enable_reasoning" not in on+ # temperature dropped so OpenAI o-series (via OpenRouter) don't reject it.+ assert on["temperature"] is None++ off = OpenRouterLLMParameters.validate(+ {+ "model": "openai/gpt-4o",+ "api_key": "k",+ "enable_reasoning": False,+ "reasoning_effort": "high",+ }+ )+ assert off["reasoning_effort"] is None+++def test_openrouter_reasoning_survives_revalidation() -> None:+ once = OpenRouterLLMParameters.validate(+ {+ "model": "openai/gpt-5",+ "api_key": "k",+ "enable_reasoning": True,+ "reasoning_effort": "high",+ }+ )+ assert once["reasoning_effort"] == "high"+ # Reloading a saved config (no enable_reasoning key) must keep reasoning on.+ twice = OpenRouterLLMParameters.validate(dict(once))+ assert twice["reasoning_effort"] == "high"+ assert twice["temperature"] is None+++ ("params", "default_base"),+ [+ (NvidiaBuildLLMParameters, _NVIDIA_BUILD_API_BASE),+ (OpenRouterLLMParameters, _OPENROUTER_API_BASE),+ ],+)+def test_branded_llm_blank_api_base_falls_back_to_default(+ params: type, default_base: str+) -> None:+ validated = params.validate({"model": "m", "api_key": "k", "api_base": " "})++ assert validated["api_base"] == default_base+++ "params",+ [NvidiaBuildLLMParameters, OpenRouterLLMParameters],+)+def test_branded_llm_honours_api_base_override(params: type) -> None:+ validated = params.validate(+ {"model": "m", "api_key": "k", "api_base": "https://proxy.internal/v1"}+ )++ assert validated["api_base"] == "https://proxy.internal/v1"+++ ("adapter", "default_base"),+ [+ (NvidiaBuildLLMAdapter, _NVIDIA_BUILD_API_BASE),+ (OpenRouterLLMAdapter, _OPENROUTER_API_BASE),+ ],+)+def test_branded_llm_schema_exposes_api_base_with_default(+ adapter: type, default_base: str+) -> None:+ schema = json.loads(adapter.get_json_schema())++ assert schema["properties"]["api_base"]["default"] == default_base+ assert "api_base" not in schema["required"]+ assert "model" in schema["required"]+++# --- Branded / generic embedding adapters ---------------------------------+++def test_nvidia_embedding_registered_and_routes_via_nvidia_nim() -> None:+ adapter_id = NvidiaBuildEmbeddingAdapter.get_id()+ assert adapter_id in embedding_adapters++ validated = NvidiaBuildEmbeddingParameters.validate(+ {"model": "nvidia/nv-embedqa-e5-v5", "api_key": "k"}+ )+ assert validated["model"] == "nvidia_nim/nvidia/nv-embedqa-e5-v5"+ assert validated["api_base"] == _NVIDIA_BUILD_API_BASE+++def test_nvidia_embedding_defaults_encoding_format_to_float() -> None:+ # NVIDIA rejects the null encoding_format LiteLLM sends when unset.+ validated = NvidiaBuildEmbeddingParameters.validate(+ {"model": "nvidia/nv-embedqa-e5-v5", "api_key": "k"}+ )+ assert validated["encoding_format"] == "float"+++def test_compatible_embedding_defaults_encoding_format_to_float() -> None:+ validated = OpenAICompatibleEmbeddingParameters.validate(+ {"model": "BAAI/bge-m3", "api_base": "https://gw.example/v1"}+ )+ assert validated["encoding_format"] == "float"+++def test_nvidia_embedding_honours_api_base_override() -> None:+ validated = NvidiaBuildEmbeddingParameters.validate(+ {"model": "m", "api_key": "k", "api_base": "https://proxy.internal/v1"}+ )+ assert validated["api_base"] == "https://proxy.internal/v1"+++def test_nvidia_embedding_model_prefix_is_idempotent() -> None:+ once = NvidiaBuildEmbeddingParameters.validate({"model": "m", "api_key": "k"})+ twice = NvidiaBuildEmbeddingParameters.validate(dict(once))+ assert twice["model"] == once["model"] == "nvidia_nim/m"+++def test_compatible_embedding_registered_and_routes_via_openai() -> None:+ adapter_id = OpenAICompatibleEmbeddingAdapter.get_id()+ assert adapter_id in embedding_adapters+ assert OpenAICompatibleEmbeddingAdapter.get_provider() == "custom_openai"++ validated = OpenAICompatibleEmbeddingParameters.validate(+ {"model": "BAAI/bge-m3", "api_base": "https://gw.example/v1"}+ )+ assert validated["model"] == "openai/BAAI/bge-m3"+ assert validated["api_base"] == "https://gw.example/v1"+++def test_compatible_embedding_blank_api_key_uses_placeholder() -> None:+ # Keyless gateways still need a non-empty key or the OpenAI SDK rejects it.+ validated = OpenAICompatibleEmbeddingParameters.validate(+ {"model": "m", "api_base": "https://gw.example/v1", "api_key": " "}+ )+ assert isinstance(validated["api_key"], str)+ assert validated["api_key"].strip()+++def test_compatible_embedding_requires_api_base() -> None:+ with pytest.raises(Exception): # noqa: B017 - pydantic ValidationError+ OpenAICompatibleEmbeddingParameters.validate({"model": "m"})+++def test_compatible_embedding_schema_loadable() -> None:+ schema = json.loads(OpenAICompatibleEmbeddingAdapter.get_json_schema())+ assert schema["title"] == "OpenAI Compatible Embedding"+ assert "api_base" in schema["required"]+ assert "model" in schema["required"]+++ "adapter",+ [NvidiaBuildEmbeddingAdapter, OpenAICompatibleEmbeddingAdapter],+)+def test_embedding_schema_drops_embed_batch_size(adapter: type) -> None:+ # embed_batch_size is an inert llama-index hint; it must not be shown.+ schema = json.loads(adapter.get_json_schema())+ assert "embed_batch_size" not in schema["properties"]+++def test_embedding_strips_embed_batch_size_before_litellm(+ monkeypatch: pytest.MonkeyPatch,+) -> None:+ # Non-API fields must not reach the provider; encoding_format must be sent.+ import unstract.sdk1.embedding as emb_mod++ captured: dict = {}++ def fake_embedding(model: str, input: list, **kwargs: object) -> dict: # noqa: A002+ captured["model"] = model+ captured.update(kwargs)+ return {"data": [{"embedding": [0.0, 1.0, 2.0]}]}++ monkeypatch.setattr(emb_mod.litellm, "embedding", fake_embedding)++ emb_mod.Embedding(+ adapter_id=NvidiaBuildEmbeddingAdapter.get_id(),+ adapter_metadata={+ "adapter_name": "n",+ "model": "nvidia/nv-embedqa-e5-v5",+ "api_key": "k",+ "embed_batch_size": 10,+ },+ )++ assert "embed_batch_size" not in captured+ assert captured["encoding_format"] == "float"+ assert captured["model"] == "nvidia_nim/nvidia/nv-embedqa-e5-v5"+ # Query path must send input_type for asymmetric models.+ assert captured["input_type"] == "query"+++def _patch_capture_embedding(monkeypatch: pytest.MonkeyPatch) -> dict:+ import unstract.sdk1.embedding as emb_mod++ captured: dict = {}++ def fake_embedding(model: str, input: list, **kwargs: object) -> dict: # noqa: A002+ captured["model"] = model+ captured.update(kwargs)+ return {"data": [{"embedding": [0.0, 1.0]}] * len(input)}++ monkeypatch.setattr(emb_mod.litellm, "embedding", fake_embedding)+ return captured+++def test_nvidia_embedding_batch_sends_passage_input_type(+ monkeypatch: pytest.MonkeyPatch,+) -> None:+ import unstract.sdk1.embedding as emb_mod++ captured = _patch_capture_embedding(monkeypatch)+ emb = emb_mod.Embedding(+ adapter_id=NvidiaBuildEmbeddingAdapter.get_id(),+ adapter_metadata={"model": "nvidia/nv-embedqa-e5-v5", "api_key": "k"},+ )+ emb.get_embeddings(["a", "b"])+ assert captured["input_type"] == "passage"+++def test_compatible_embedding_omits_input_type(+ monkeypatch: pytest.MonkeyPatch,+) -> None:+ # input_type is NVIDIA-only; non-nvidia_nim models must not receive it.+ import unstract.sdk1.embedding as emb_mod++ captured = _patch_capture_embedding(monkeypatch)+ emb_mod.Embedding(+ adapter_id=OpenAICompatibleEmbeddingAdapter.get_id(),+ adapter_metadata={+ "model": "BAAI/bge-m3",+ "api_base": "https://gw.example/v1",+ "api_key": "k",+ },+ )+ assert "input_type" not in captured+ assert captured["model"] == "openai/BAAI/bge-m3"diff --git a/unstract/sdk1/tests/test_gemini_embedding.py b/unstract/sdk1/tests/test_gemini_embedding.pyindex 2bf031e3e..3bdc0f6d7 100644--- a/unstract/sdk1/tests/test_gemini_embedding.py+++ b/unstract/sdk1/tests/test_gemini_embedding.py@@ -39,9 +39,10 @@ class TestGeminiEmbeddingAdapter:schema = json.loads(GeminiEmbeddingAdapter.get_json_schema())assert set(schema["required"]) == {"adapter_name", "api_key", "model"}- def test_json_schema_no_batch_size_default(self) -> None:+ def test_json_schema_omits_batch_size(self) -> None:+ # embed_batch_size is an inert client-side hint and is not exposed.schema = json.loads(GeminiEmbeddingAdapter.get_json_schema())- assert "default" not in schema["properties"]["embed_batch_size"]+ assert "embed_batch_size" not in schema["properties"]def test_json_schema_api_key_password_format(self) -> None:schema = json.loads(GeminiEmbeddingAdapter.get_json_schema())