The most powerful and modular diffusion model GUI, api and backend with a graph/nodes interface. The fastest local inference engine in the world.
[Partner Nodes] add OpenRouter LLM node (#14007)
Alexander Piskun6ecf5eca7ac6
diff --git a/comfy_api_nodes/apis/anthropic.py b/comfy_api_nodes/apis/anthropic.pyindex 6cac537ea..46a5bb428 100644--- a/comfy_api_nodes/apis/anthropic.py+++ b/comfy_api_nodes/apis/anthropic.py@@ -35,6 +35,19 @@ class AnthropicMessage(BaseModel):content: list[AnthropicTextContent | AnthropicImageContent] = Field(...)+class AnthropicThinkingConfig(BaseModel):+ type: Literal["enabled", "disabled", "adaptive"] = Field(...)+ budget_tokens: int | None = Field(+ None, ge=1024,+ description="Reasoning budget in tokens. Used when type is 'enabled'. Must be less than max_tokens.",+ )+++class AnthropicOutputConfig(BaseModel):+ """Used with `thinking.type='adaptive'` on models like Opus 4.7."""+ effort: Literal["low", "medium", "high"] | None = Field(None)++class AnthropicMessagesRequest(BaseModel):model: str = Field(...)messages: list[AnthropicMessage] = Field(...)@@ -44,6 +57,8 @@ class AnthropicMessagesRequest(BaseModel):top_p: float | None = Field(None, ge=0.0, le=1.0)top_k: int | None = Field(None, ge=0)stop_sequences: list[str] | None = Field(None)+ thinking: AnthropicThinkingConfig | None = Field(None)+ output_config: AnthropicOutputConfig | None = Field(None)class AnthropicResponseTextBlock(BaseModel):@@ -51,6 +66,14 @@ class AnthropicResponseTextBlock(BaseModel):text: str = Field(...)+class AnthropicResponseThinkingBlock(BaseModel):+ type: Literal["thinking"] = "thinking"+ thinking: str = Field(...)+++AnthropicResponseBlock = AnthropicResponseTextBlock | AnthropicResponseThinkingBlock++class AnthropicCacheCreationUsage(BaseModel):ephemeral_5m_input_tokens: int | None = Field(None)ephemeral_1h_input_tokens: int | None = Field(None)@@ -69,7 +92,7 @@ class AnthropicMessagesResponse(BaseModel):type: str | None = Field(None)role: str | None = Field(None)model: str | None = Field(None)- content: list[AnthropicResponseTextBlock] | None = Field(None)+ content: list[AnthropicResponseBlock] | None = Field(None)stop_reason: str | None = Field(None)stop_sequence: str | None = Field(None)usage: AnthropicMessagesUsage | None = Field(None)diff --git a/comfy_api_nodes/apis/openrouter.py b/comfy_api_nodes/apis/openrouter.pynew file mode 100644index 000000000..e30d9bcfb--- /dev/null+++ b/comfy_api_nodes/apis/openrouter.py@@ -0,0 +1,93 @@+"""Pydantic models for the OpenRouter chat completions API.++See: https://openrouter.ai/docs/api/api-reference/chat/send-chat-completion-request+"""++from typing import Literal++from pydantic import BaseModel, Field+++class OpenRouterTextContent(BaseModel):+ type: Literal["text"] = "text"+ text: str = Field(...)+++class OpenRouterImageUrl(BaseModel):+ url: str = Field(...)+++class OpenRouterImageContent(BaseModel):+ type: Literal["image_url"] = "image_url"+ image_url: OpenRouterImageUrl = Field(...)+++class OpenRouterVideoUrl(BaseModel):+ url: str = Field(...)+++class OpenRouterVideoContent(BaseModel):+ type: Literal["video_url"] = "video_url"+ video_url: OpenRouterVideoUrl = Field(...)+++OpenRouterContentBlock = OpenRouterTextContent | OpenRouterImageContent | OpenRouterVideoContent+++class OpenRouterMessage(BaseModel):+ role: Literal["system", "user", "assistant"] = Field(...)+ content: str | list[OpenRouterContentBlock] = Field(...)+++class OpenRouterReasoningConfig(BaseModel):+ effort: str | None = Field(None)+ exclude: bool | None = Field(None, description="If true, model reasons but reasoning is excluded from response.")+++class OpenRouterWebSearchOptions(BaseModel):+ search_context_size: str | None = Field(None)+++class OpenRouterChatRequest(BaseModel):+ model: str = Field(...)+ messages: list[OpenRouterMessage] = Field(...)+ seed: int | None = Field(None)+ reasoning: OpenRouterReasoningConfig | None = Field(None)+ web_search_options: OpenRouterWebSearchOptions | None = Field(None)+ stream: bool = Field(False)+++class OpenRouterUsage(BaseModel):+ prompt_tokens: int | None = Field(None)+ completion_tokens: int | None = Field(None)+ total_tokens: int | None = Field(None)+ cost: float | None = Field(None, description="Server-side authoritative USD cost of the call.")+++class OpenRouterResponseMessage(BaseModel):+ role: str | None = Field(None)+ content: str | None = Field(None)+ reasoning: str | None = Field(None)+ refusal: str | None = Field(None)+++class OpenRouterChoice(BaseModel):+ index: int | None = Field(None)+ message: OpenRouterResponseMessage | None = Field(None)+ finish_reason: str | None = Field(None)+++class OpenRouterError(BaseModel):+ code: int | str | None = Field(None)+ message: str | None = Field(None)+ metadata: dict | None = Field(None)+++class OpenRouterChatResponse(BaseModel):+ id: str | None = Field(None)+ model: str | None = Field(None)+ object: str | None = Field(None)+ provider: str | None = Field(None)+ choices: list[OpenRouterChoice] | None = Field(None)+ usage: OpenRouterUsage | None = Field(None)+ error: OpenRouterError | None = Field(None)diff --git a/comfy_api_nodes/nodes_anthropic.py b/comfy_api_nodes/nodes_anthropic.pyindex 28dd70d4e..42ec5708f 100644--- a/comfy_api_nodes/nodes_anthropic.py+++ b/comfy_api_nodes/nodes_anthropic.py@@ -9,8 +9,11 @@ from comfy_api_nodes.apis.anthropic import (AnthropicMessage,AnthropicMessagesRequest,AnthropicMessagesResponse,+ AnthropicOutputConfig,+ AnthropicResponseTextBlock,AnthropicRole,AnthropicTextContent,+ AnthropicThinkingConfig,)from comfy_api_nodes.util import (ApiEndpoint,@@ -32,15 +35,29 @@ CLAUDE_MODELS: dict[str, str] = {"Haiku 4.5": "claude-haiku-4-5-20251001",}+_THINKING_UNSUPPORTED = {"Haiku 4.5"}+# Models that use the newer "adaptive" thinking mode (Opus 4.7 requires it; older models keep the explicit budget API).+# Anthropic decides the actual budget when adaptive is used, based on the `output_config.effort` hint.+_ADAPTIVE_THINKING_MODELS = {"Opus 4.7", "Opus 4.6", "Sonnet 4.6"}-def _claude_model_inputs():- return [+# Budget mode (Sonnet 4.5): effort -> reasoning budget in tokens. Must be < max_tokens.+# Sized so even the "high" budget fits comfortably under the default max_tokens=32768.+_REASONING_BUDGET: dict[str, int] = {+ "low": 2048,+ "medium": 8192,+ "high": 16384,+}+_REASONING_EFFORTS = ["off", "low", "medium", "high"]+++def _claude_model_inputs(model_label: str):+ inputs: list = [IO.Int.Input("max_tokens",- default=16000,- min=32,- max=32000,- tooltip="Maximum number of tokens to generate before stopping.",+ default=32768,+ min=4096,+ max=64000,+ tooltip="Maximum number of tokens to generate (includes reasoning tokens when enabled).",advanced=True,),IO.Float.Input(@@ -49,10 +66,24 @@ def _claude_model_inputs():min=0.0,max=1.0,step=0.01,- tooltip="Controls randomness. 0.0 is deterministic, 1.0 is most random. Ignored for Opus 4.7.",+ tooltip=(+ "Controls randomness. 0.0 is deterministic, 1.0 is most random. "+ "Ignored for Opus 4.7 and any model when reasoning_effort is set."+ ),advanced=True,),]+ if model_label not in _THINKING_UNSUPPORTED:+ inputs.append(+ IO.Combo.Input(+ "reasoning_effort",+ options=_REASONING_EFFORTS,+ default="off",+ tooltip="Extended thinking effort. 'off' disables reasoning.",+ advanced=True,+ )+ )+ return inputsdef _model_price_per_million(model: str) -> tuple[float, float] | None:@@ -95,7 +126,11 @@ def calculate_tokens_price(response: AnthropicMessagesResponse) -> float | None:def _get_text_from_response(response: AnthropicMessagesResponse) -> str:if not response.content:return ""- return "\n".join(block.text for block in response.content if block.text)+ # Thinking blocks are silently dropped — we never want reasoning in the output.+ return "\n".join(+ block.text for block in response.content+ if isinstance(block, AnthropicResponseTextBlock) and block.text+ )async def _build_image_content_blocks(@@ -133,7 +168,10 @@ class ClaudeNode(IO.ComfyNode):),IO.DynamicCombo.Input("model",- options=[IO.DynamicCombo.Option(label, _claude_model_inputs()) for label in CLAUDE_MODELS],+ options=[+ IO.DynamicCombo.Option(label, _claude_model_inputs(label))+ for label in CLAUDE_MODELS+ ],tooltip="The Claude model used to generate the response.",),IO.Int.Input(@@ -207,8 +245,29 @@ class ClaudeNode(IO.ComfyNode):) -> IO.NodeOutput:validate_string(prompt, strip_whitespace=True, min_length=1)model_label = model["model"]- max_tokens = model["max_tokens"]- temperature = None if model_label == "Opus 4.7" else model["temperature"]+ max_tokens = model.get("max_tokens", 32768)+ reasoning_effort = model.get("reasoning_effort", "off")+ thinking_enabled = reasoning_effort not in ("off", None) and model_label not in _THINKING_UNSUPPORTED++ # Anthropic requires temperature to be unset (defaults to 1.0) when thinking is enabled.+ # Opus 4.7 also rejects user-supplied temperature.+ if thinking_enabled or model_label == "Opus 4.7":+ temperature = None+ else:+ temperature = model.get("temperature", 1.0)++ thinking_cfg: AnthropicThinkingConfig | None = None+ output_cfg: AnthropicOutputConfig | None = None+ if thinking_enabled:+ if model_label in _ADAPTIVE_THINKING_MODELS:+ # Adaptive mode - Anthropic chooses the budget based on effort hint+ thinking_cfg = AnthropicThinkingConfig(type="adaptive")+ output_cfg = AnthropicOutputConfig(effort=reasoning_effort)+ else:+ # Budget mode (Sonnet 4.5). Leave at least 1024 tokens for the actual response+ budget = _REASONING_BUDGET[reasoning_effort]+ budget = min(budget, max(1024, max_tokens - 1024))+ thinking_cfg = AnthropicThinkingConfig(type="enabled", budget_tokens=budget)image_tensors: list[Input.Image] = [t for t in (images or {}).values() if t is not None]if sum(get_number_of_images(t) for t in image_tensors) > CLAUDE_MAX_IMAGES:@@ -229,6 +288,8 @@ class ClaudeNode(IO.ComfyNode):messages=[AnthropicMessage(role=AnthropicRole.user, content=content)],system=system_prompt or None,temperature=temperature,+ thinking=thinking_cfg,+ output_config=output_cfg,),price_extractor=calculate_tokens_price,)diff --git a/comfy_api_nodes/nodes_openrouter.py b/comfy_api_nodes/nodes_openrouter.pynew file mode 100644index 000000000..031301870--- /dev/null+++ b/comfy_api_nodes/nodes_openrouter.py@@ -0,0 +1,374 @@+"""API Nodes for OpenRouter LLM chat completions."""++from dataclasses import dataclass+from typing import Literal++from typing_extensions import override++from comfy_api.latest import IO, ComfyExtension, Input+from comfy_api_nodes.apis.openrouter import (+ OpenRouterChatRequest,+ OpenRouterChatResponse,+ OpenRouterContentBlock,+ OpenRouterImageContent,+ OpenRouterImageUrl,+ OpenRouterMessage,+ OpenRouterReasoningConfig,+ OpenRouterTextContent,+ OpenRouterVideoContent,+ OpenRouterVideoUrl,+ OpenRouterWebSearchOptions,+)+from comfy_api_nodes.util import (+ ApiEndpoint,+ get_number_of_images,+ sync_op,+ upload_images_to_comfyapi,+ upload_video_to_comfyapi,+ validate_string,+)++OPENROUTER_CHAT_ENDPOINT = "/proxy/openrouter/api/v1/chat/completions"+++Profile = Literal["standard", "reasoning", "frontier_reasoning", "perplexity", "perplexity_reasoning"]+++@dataclass(frozen=True)+class _ModelSpec:+ slug: str # exact OpenRouter model id+ profile: Profile+ price_in: float # USD per token (prompt)+ price_out: float # USD per token (completion)+ max_images: int = 0 # 0 = no image input; otherwise max URL-passed images supported+ max_videos: int = 0 # 0 = no video input; otherwise max URL-passed videos supported+++MODELS: list[_ModelSpec] = [+ _ModelSpec("anthropic/claude-opus-4.7", "frontier_reasoning", 0.000005, 0.000025, max_images=20),+ _ModelSpec("openai/gpt-5.5-pro", "frontier_reasoning", 0.00003, 0.00018, max_images=20),+ _ModelSpec("openai/gpt-5.5", "frontier_reasoning", 0.000005, 0.00003, max_images=20),+ _ModelSpec("google/gemini-3.5-flash", "reasoning", 0.0000015, 0.000009, max_images=20, max_videos=4),+ _ModelSpec("x-ai/grok-4.20", "reasoning", 0.00000125, 0.0000025, max_images=20),+ _ModelSpec("x-ai/grok-4.3", "reasoning", 0.00000125, 0.0000025, max_images=20),+ _ModelSpec("deepseek/deepseek-v4-pro", "reasoning", 0.000000435, 0.00000087),+ _ModelSpec("deepseek/deepseek-v4-flash", "reasoning", 0.000000112, 0.000000224),+ _ModelSpec("deepseek/deepseek-v3.2", "reasoning", 0.000000252, 0.000000378),+ _ModelSpec("qwen/qwen3.6-max-preview", "reasoning", 0.00000104, 0.00000624),+ _ModelSpec("qwen/qwen3.6-plus", "reasoning", 0.000000325, 0.00000195, max_images=10, max_videos=4),+ _ModelSpec("qwen/qwen3.6-flash", "reasoning", 0.0000001875, 0.000001125, max_images=10, max_videos=4),+ _ModelSpec("mistralai/mistral-large-2512", "standard", 0.0000005, 0.0000015, max_images=8),+ _ModelSpec("mistralai/mistral-medium-3-5", "reasoning", 0.0000015, 0.0000075, max_images=8),+ _ModelSpec("z-ai/glm-4.6", "reasoning", 0.00000043, 0.00000174),+ _ModelSpec("z-ai/glm-5", "reasoning", 0.0000006, 0.00000192),+ _ModelSpec("moonshotai/kimi-k2.6", "reasoning", 0.00000073, 0.00000349, max_images=10),+ _ModelSpec("moonshotai/kimi-k2-thinking", "reasoning", 0.0000006, 0.0000025),+ _ModelSpec("perplexity/sonar-pro", "perplexity", 0.000003, 0.000015),+ _ModelSpec("perplexity/sonar-reasoning-pro", "perplexity_reasoning", 0.000002, 0.000008),+ _ModelSpec("perplexity/sonar-deep-research", "perplexity_reasoning", 0.000002, 0.000008),+]++_MODELS_BY_SLUG: dict[str, _ModelSpec] = {m.slug: m for m in MODELS}+_REASONING_EFFORTS = ["off", "low", "medium", "high"]+_SEARCH_CONTEXT_SIZES = ["low", "medium", "high"]+++def _reasoning_extra_inputs() -> list:+ return [+ IO.Combo.Input(+ "reasoning_effort",+ options=_REASONING_EFFORTS,+ default="off",+ tooltip="Reasoning effort. 'off' disables reasoning entirely.",+ advanced=True,+ ),+ ]+++def _perplexity_extra_inputs() -> list:+ return [+ IO.Combo.Input(+ "search_context_size",+ options=_SEARCH_CONTEXT_SIZES,+ default="medium",+ tooltip="How much web search context to retrieve. Larger = more grounded but slower/pricier.",+ advanced=True,+ ),+ ]+++def _profile_inputs(profile: Profile) -> list:+ if profile == "standard":+ return []+ if profile in ("reasoning", "frontier_reasoning"):+ return _reasoning_extra_inputs()+ if profile == "perplexity":+ return _perplexity_extra_inputs()+ if profile == "perplexity_reasoning":+ return _perplexity_extra_inputs() + _reasoning_extra_inputs()+ raise ValueError(f"Unknown profile: {profile}")+++def _media_inputs(spec: _ModelSpec) -> list:+ extras: list = []+ if spec.max_images > 0:+ extras.append(+ IO.Autogrow.Input(+ "images",+ template=IO.Autogrow.TemplateNames(+ IO.Image.Input("image"),+ names=[f"image_{i}" for i in range(1, spec.max_images + 1)],+ min=0,+ ),+ tooltip=f"Optional reference image(s) — up to {spec.max_images}. Sent as URLs.",+ )+ )+ if spec.max_videos > 0:+ extras.append(+ IO.Autogrow.Input(+ "videos",+ template=IO.Autogrow.TemplateNames(+ IO.Video.Input("video"),+ names=[f"video_{i}" for i in range(1, spec.max_videos + 1)],+ min=0,+ ),+ tooltip=f"Optional reference video(s) — up to {spec.max_videos}. Sent as URLs.",+ )+ )+ return extras+++def _inputs_for_model(spec: _ModelSpec) -> list:+ return _profile_inputs(spec.profile) + _media_inputs(spec)+++def _build_model_options() -> list[IO.DynamicCombo.Option]:+ return [IO.DynamicCombo.Option(spec.slug, _inputs_for_model(spec)) for spec in MODELS]+++def _calculate_price(response: OpenRouterChatResponse) -> float | None:+ if response.usage and response.usage.cost is not None:+ return float(response.usage.cost)+ return None+++def _price_badge_jsonata() -> str:+ rates_pairs = []+ for spec in MODELS:+ prompt_per_1k = spec.price_in * 1000+ completion_per_1k = spec.price_out * 1000+ rates_pairs.append(f' "{spec.slug}": [{prompt_per_1k:.8g}, {completion_per_1k:.8g}]')+ rates_block = ",\n".join(rates_pairs)+ return (+ "(\n"+ " $rates := {\n"+ f"{rates_block}\n"+ " };\n"+ " $r := $lookup($rates, widgets.model);\n"+ " $r ? {\n"+ ' "type": "list_usd",\n'+ ' "usd": $r,\n'+ ' "format": { "approximate": true, "separator": "-", "suffix": " per 1K tokens" }\n'+ ' } : {"type": "text", "text": "Token-based"}\n'+ ")"+ )+++async def _build_image_blocks(+ cls: type[IO.ComfyNode], spec: _ModelSpec, images: list[Input.Image]+) -> list[OpenRouterImageContent]:+ urls = await upload_images_to_comfyapi(+ cls,+ images,+ max_images=spec.max_images,+ total_pixels=2048 * 2048,+ mime_type="image/png",+ wait_label="Uploading reference images",+ )+ return [OpenRouterImageContent(image_url=OpenRouterImageUrl(url=url)) for url in urls]+++async def _build_video_blocks(cls: type[IO.ComfyNode], videos: list[Input.Video]) -> list[OpenRouterVideoContent]:+ blocks: list[OpenRouterVideoContent] = []+ total = len(videos)+ for idx, video in enumerate(videos):+ label = "Uploading reference video"+ if total > 1:+ label = f"{label} ({idx + 1}/{total})"+ url = await upload_video_to_comfyapi(cls, video, wait_label=label)+ blocks.append(OpenRouterVideoContent(video_url=OpenRouterVideoUrl(url=url)))+ return blocks+++def _user_message(prompt: str, media_blocks: list[OpenRouterContentBlock]) -> OpenRouterMessage:+ if not media_blocks:+ return OpenRouterMessage(role="user", content=prompt)+ blocks: list[OpenRouterContentBlock] = list(media_blocks)+ blocks.append(OpenRouterTextContent(text=prompt))+ return OpenRouterMessage(role="user", content=blocks)+++def _build_messages(+ system_prompt: str, prompt: str, media_blocks: list[OpenRouterContentBlock]+) -> list[OpenRouterMessage]:+ messages: list[OpenRouterMessage] = []+ if system_prompt:+ messages.append(OpenRouterMessage(role="system", content=system_prompt))+ messages.append(_user_message(prompt, media_blocks))+ return messages+++def _build_request(+ slug: str,+ system_prompt: str,+ prompt: str,+ media_blocks: list[OpenRouterContentBlock],+ *,+ seed: int,+ reasoning_effort: str | None,+ search_context_size: str | None,+) -> OpenRouterChatRequest:+ reasoning_cfg: OpenRouterReasoningConfig | None = None+ if reasoning_effort and reasoning_effort != "off":+ # exclude=True asks providers to reason internally but not return the trace+ reasoning_cfg = OpenRouterReasoningConfig(effort=reasoning_effort, exclude=True)+ web_search_cfg: OpenRouterWebSearchOptions | None = None+ if search_context_size:+ web_search_cfg = OpenRouterWebSearchOptions(search_context_size=search_context_size)+ return OpenRouterChatRequest(+ model=slug,+ messages=_build_messages(system_prompt, prompt, media_blocks),+ seed=seed if seed > 0 else None,+ reasoning=reasoning_cfg,+ web_search_options=web_search_cfg,+ )+++def _extract_text(response: OpenRouterChatResponse) -> str:+ if response.error:+ code = response.error.code if response.error.code is not None else "unknown"+ raise ValueError(f"OpenRouter error ({code}): {response.error.message or 'no message'}")+ if not response.choices:+ raise ValueError("Empty response from OpenRouter (no choices).")+ message = response.choices[0].message+ if not message:+ raise ValueError("Empty response from OpenRouter (no message).")+ if message.refusal:+ raise ValueError(f"Model refused to respond: {message.refusal}")+ return message.content or ""+++class OpenRouterLLMNode(IO.ComfyNode):++ @classmethod+ def define_schema(cls):+ return IO.Schema(+ node_id="OpenRouterLLMNode",+ display_name="OpenRouter LLM",+ category="api node/text/OpenRouter",+ essentials_category="Text Generation",+ description=(+ "Generate text responses through OpenRouter. Routes to a curated set of popular "+ "models from xAI, DeepSeek, Qwen, Mistral, Z.AI (GLM), Moonshot (Kimi), and "+ "Perplexity Sonar."+ ),+ inputs=[+ IO.String.Input(+ "prompt",+ multiline=True,+ default="",+ tooltip="Text input to the model.",+ ),+ IO.DynamicCombo.Input(+ "model",+ options=_build_model_options(),+ tooltip="The OpenRouter model used to generate the response.",+ ),+ IO.Int.Input(+ "seed",+ default=0,+ min=0,+ max=2147483647,+ control_after_generate=True,+ tooltip="Seed for sampling. Set to 0 to omit. Most models treat this as a hint only.",+ ),+ IO.String.Input(+ "system_prompt",+ multiline=True,+ default="",+ optional=True,+ advanced=True,+ tooltip="Foundational instructions that dictate the model's behavior.",+ ),+ ],+ outputs=[IO.String.Output()],+ hidden=[+ IO.Hidden.auth_token_comfy_org,+ IO.Hidden.api_key_comfy_org,+ IO.Hidden.unique_id,+ ],+ is_api_node=True,+ price_badge=IO.PriceBadge(+ depends_on=IO.PriceBadgeDepends(widgets=["model"]),+ expr=_price_badge_jsonata(),+ ),+ )++ @classmethod+ async def execute(+ cls,+ prompt: str,+ model: dict,+ seed: int,+ system_prompt: str = "",+ ) -> IO.NodeOutput:+ validate_string(prompt, strip_whitespace=True, min_length=1)+ slug: str = model["model"]+ spec = _MODELS_BY_SLUG.get(slug)+ if spec is None:+ raise ValueError(f"Unknown OpenRouter model: {slug}")++ reasoning_effort: str | None = model.get("reasoning_effort")+ search_context_size: str | None = model.get("search_context_size")++ image_tensors: list[Input.Image] = [t for t in (model.get("images") or {}).values() if t is not None]+ if image_tensors and sum(get_number_of_images(t) for t in image_tensors) > spec.max_images:+ raise ValueError(f"Up to {spec.max_images} images are supported for {slug}.")+ video_inputs: list[Input.Video] = [v for v in (model.get("videos") or {}).values() if v is not None]+ if video_inputs and len(video_inputs) > spec.max_videos:+ raise ValueError(f"Up to {spec.max_videos} videos are supported for {slug}.")++ media_blocks: list[OpenRouterContentBlock] = []+ if image_tensors:+ media_blocks.extend(await _build_image_blocks(cls, spec, image_tensors))+ if video_inputs:+ media_blocks.extend(await _build_video_blocks(cls, video_inputs))++ request = _build_request(+ slug,+ system_prompt,+ prompt,+ media_blocks,+ seed=seed,+ reasoning_effort=reasoning_effort,+ search_context_size=search_context_size,+ )++ response = await sync_op(+ cls,+ ApiEndpoint(path=OPENROUTER_CHAT_ENDPOINT, method="POST"),+ response_model=OpenRouterChatResponse,+ data=request,+ price_extractor=_calculate_price,+ )+ return IO.NodeOutput(_extract_text(response))+++class OpenRouterExtension(ComfyExtension):+ @override+ async def get_node_list(self) -> list[type[IO.ComfyNode]]:+ return [OpenRouterLLMNode]+++async def comfy_entrypoint() -> OpenRouterExtension:+ return OpenRouterExtension()