Skip to content

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.py
index 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.py
new file mode 100644
index 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.py
index 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 inputs
def _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.py
new file mode 100644
index 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()