intentkit 0.6.13.dev2__py3-none-any.whl → 0.8.17__py3-none-any.whl

intentkit/models/llm.py

@@ -1,28 +1,102 @@
+import csv
 import json
 import logging
-from datetime import datetime, timezone
-from decimal import Decimal
+from datetime import UTC, datetime
+from decimal import ROUND_HALF_UP, Decimal
 from enum import Enum
-from typing import Annotated, Any, Optional
+from pathlib import Path
+from typing import Annotated, Any
 
+from intentkit.config.config import config
 from intentkit.models.app_setting import AppSetting
 from intentkit.models.base import Base
 from intentkit.models.db import get_session
 from intentkit.models.redis import get_redis
-from intentkit.utils.error import IntentKitLookUpError
-from langchain_core.language_models import LanguageModelLike
+from intentkit.utils.error import IntentKitAPIError
+from langchain.chat_models.base import BaseChatModel
 from pydantic import BaseModel, ConfigDict, Field
 from sqlalchemy import Boolean, Column, DateTime, Integer, Numeric, String, func, select
+from sqlalchemy.ext.asyncio import AsyncSession
 
 logger = logging.getLogger(__name__)
 
 _credit_per_usdc = None
+FOURPLACES = Decimal("0.0001")
+
+
+def _parse_bool(value: str | None) -> bool:
+    if value is None:
+        return False
+    return value.strip().lower() in {"true", "1", "yes"}
+
+
+def _parse_optional_int(value: str | None) -> int | None:
+    if value is None:
+        return None
+    value = value.strip()
+    return int(value) if value else None
+
+
+def _load_default_llm_models() -> dict[str, "LLMModelInfo"]:
+    """Load default LLM models from a CSV file."""
+
+    path = Path(__file__).with_name("llm.csv")
+    if not path.exists():
+        logger.warning("Default LLM CSV not found at %s", path)
+        return {}
+
+    defaults: dict[str, LLMModelInfo] = {}
+    with path.open(newline="", encoding="utf-8") as csvfile:
+        reader = csv.DictReader(csvfile)
+        for row in reader:
+            try:
+                timestamp = datetime.now(UTC)
+                model = LLMModelInfo(
+                    id=row["id"],
+                    name=row["name"],
+                    provider=LLMProvider(row["provider"]),
+                    enabled=_parse_bool(row.get("enabled")),
+                    input_price=Decimal(row["input_price"]),
+                    output_price=Decimal(row["output_price"]),
+                    price_level=_parse_optional_int(row.get("price_level")),
+                    context_length=int(row["context_length"]),
+                    output_length=int(row["output_length"]),
+                    intelligence=int(row["intelligence"]),
+                    speed=int(row["speed"]),
+                    supports_image_input=_parse_bool(row.get("supports_image_input")),
+                    supports_skill_calls=_parse_bool(row.get("supports_skill_calls")),
+                    supports_structured_output=_parse_bool(
+                        row.get("supports_structured_output")
+                    ),
+                    has_reasoning=_parse_bool(row.get("has_reasoning")),
+                    supports_search=_parse_bool(row.get("supports_search")),
+                    supports_temperature=_parse_bool(row.get("supports_temperature")),
+                    supports_frequency_penalty=_parse_bool(
+                        row.get("supports_frequency_penalty")
+                    ),
+                    supports_presence_penalty=_parse_bool(
+                        row.get("supports_presence_penalty")
+                    ),
+                    api_base=row.get("api_base", "").strip() or None,
+                    timeout=int(row.get("timeout", "") or 180),
+                    created_at=timestamp,
+                    updated_at=timestamp,
+                )
+            except Exception as exc:
+                logger.error(
+                    "Failed to load default LLM model %s: %s", row.get("id"), exc
+                )
+                continue
+            defaults[model.id] = model
+
+    return defaults
 
 
 class LLMProvider(str, Enum):
     OPENAI = "openai"
     DEEPSEEK = "deepseek"
     XAI = "xai"
+    GATEWAYZ = "gatewayz"
     ETERNAL = "eternal"
     REIGENT = "reigent"
     VENICE = "venice"
@@ -33,9 +107,10 @@ class LLMProvider(str, Enum):
             self.OPENAI: "OpenAI",
             self.DEEPSEEK: "DeepSeek",
             self.XAI: "xAI",
-            self.ETERNAL: "Others",
-            self.REIGENT: "Others",
-            self.VENICE: "Others",
+            self.GATEWAYZ: "Gatewayz",
+            self.ETERNAL: "Eternal",
+            self.REIGENT: "Reigent",
+            self.VENICE: "Venice",
         }
         return display_names.get(self, self.value)
 
@@ -79,7 +154,7 @@ class LLMModelInfoTable(Base):
         DateTime(timezone=True),
         nullable=False,
         server_default=func.now(),
-        onupdate=lambda: datetime.now(timezone.utc),
+        onupdate=lambda: datetime.now(UTC),
     )
 
 
@@ -98,7 +173,7 @@ class LLMModelInfo(BaseModel):
     enabled: bool = Field(default=True)
     input_price: Decimal  # Price per 1M input tokens in USD
     output_price: Decimal  # Price per 1M output tokens in USD
-    price_level: Optional[int] = Field(
+    price_level: int | None = Field(
         default=None, ge=1, le=5
     )  # Price level rating from 1-5
     context_length: int  # Maximum context length in tokens
@@ -123,22 +198,20 @@ class LLMModelInfo(BaseModel):
     supports_presence_penalty: bool = (
         True  # Whether the model supports presence_penalty parameter
     )
-    api_base: Optional[str] = (
-        None  # Custom API base URL if not using provider's default
-    )
+    api_base: str | None = None  # Custom API base URL if not using provider's default
     timeout: int = 180  # Default timeout in seconds
     created_at: Annotated[
         datetime,
         Field(
             description="Timestamp when this data was created",
-            default=datetime.now(timezone.utc),
+            default=datetime.now(UTC),
         ),
     ]
     updated_at: Annotated[
         datetime,
         Field(
             description="Timestamp when this data was updated",
-            default=datetime.now(timezone.utc),
+            default=datetime.now(UTC),
         ),
     ]
 
@@ -207,7 +280,31 @@ class LLMModelInfo(BaseModel):
             return model_info
 
         # Not found anywhere
-        raise IntentKitLookUpError(f"Model {model_id} not found")
+        raise IntentKitAPIError(
+            400,
+            "ModelNotFound",
+            f"Model {model_id} not found, maybe deprecated, please change it in the agent configuration.",
+        )
+
+    @classmethod
+    async def get_all(cls, session: AsyncSession | None = None) -> list["LLMModelInfo"]:
+        """Return all models merged from defaults and database overrides."""
+
+        if session is None:
+            async with get_session() as db:
+                return await cls.get_all(session=db)
+
+        models: dict[str, LLMModelInfo] = {
+            model_id: model.model_copy(deep=True)
+            for model_id, model in AVAILABLE_MODELS.items()
+        }
+
+        result = await session.execute(select(LLMModelInfoTable))
+        for row in result.scalars():
+            model_info = cls.model_validate(row)
+            models[model_info.id] = model_info
+
+        return list(models.values())
 
     async def calculate_cost(self, input_tokens: int, output_tokens: int) -> Decimal:
         global _credit_per_usdc
@@ -219,335 +316,18 @@ class LLMModelInfo(BaseModel):
             * Decimal(input_tokens)
             * self.input_price
             / Decimal(1000000)
-        )
+        ).quantize(FOURPLACES, rounding=ROUND_HALF_UP)
         output_cost = (
             _credit_per_usdc
             * Decimal(output_tokens)
             * self.output_price
             / Decimal(1000000)
-        )
-        return input_cost + output_cost
-
-
-# Define all available models
-AVAILABLE_MODELS = {
-    # OpenAI models
-    "gpt-4o": LLMModelInfo(
-        id="gpt-4o",
-        name="GPT-4o",
-        provider=LLMProvider.OPENAI,
-        input_price=Decimal("2.50"),  # per 1M input tokens
-        output_price=Decimal("10.00"),  # per 1M output tokens
-        context_length=128000,
-        output_length=4096,
-        intelligence=4,
-        speed=3,
-        supports_image_input=True,
-        supports_skill_calls=True,
-        supports_structured_output=True,
-        supports_search=True,
-        supports_frequency_penalty=False,
-        supports_presence_penalty=False,
-    ),
-    "gpt-4o-mini": LLMModelInfo(
-        id="gpt-4o-mini",
-        name="GPT-4o Mini",
-        provider=LLMProvider.OPENAI,
-        input_price=Decimal("0.15"),  # per 1M input tokens
-        output_price=Decimal("0.60"),  # per 1M output tokens
-        context_length=128000,
-        output_length=4096,
-        intelligence=3,
-        speed=4,
-        supports_image_input=False,
-        supports_skill_calls=True,
-        supports_structured_output=True,
-        supports_search=True,
-        supports_frequency_penalty=False,
-        supports_presence_penalty=False,
-    ),
-    "gpt-5-nano": LLMModelInfo(
-        id="gpt-5-nano",
-        name="GPT-5 Nano",
-        provider=LLMProvider.OPENAI,
-        input_price=Decimal("0.05"),  # per 1M input tokens
-        output_price=Decimal("0.4"),  # per 1M output tokens
-        context_length=400000,
-        output_length=128000,
-        intelligence=3,
-        speed=5,
-        supports_image_input=True,
-        supports_skill_calls=True,
-        supports_structured_output=True,
-        supports_temperature=False,
-        supports_frequency_penalty=False,
-        supports_presence_penalty=False,
-    ),
-    "gpt-5-mini": LLMModelInfo(
-        id="gpt-5-mini",
-        name="GPT-5 Mini",
-        provider=LLMProvider.OPENAI,
-        input_price=Decimal("0.25"),  # per 1M input tokens
-        output_price=Decimal("2"),  # per 1M output tokens
-        context_length=400000,
-        output_length=128000,
-        intelligence=4,
-        speed=4,
-        supports_image_input=True,
-        supports_skill_calls=True,
-        supports_structured_output=True,
-        supports_search=True,
-        supports_temperature=False,
-        supports_frequency_penalty=False,
-        supports_presence_penalty=False,
-    ),
-    "gpt-5": LLMModelInfo(
-        id="gpt-5",
-        name="GPT-5",
-        provider=LLMProvider.OPENAI,
-        input_price=Decimal("1.25"),  # per 1M input tokens
-        output_price=Decimal("10.00"),  # per 1M output tokens
-        context_length=400000,
-        output_length=128000,
-        intelligence=5,
-        speed=3,
-        supports_image_input=True,
-        supports_skill_calls=True,
-        supports_structured_output=True,
-        supports_search=True,
-        supports_temperature=False,
-        supports_frequency_penalty=False,
-        supports_presence_penalty=False,
-    ),
-    "gpt-4.1-nano": LLMModelInfo(
-        id="gpt-4.1-nano",
-        name="GPT-4.1 Nano",
-        provider=LLMProvider.OPENAI,
-        input_price=Decimal("0.1"),  # per 1M input tokens
-        output_price=Decimal("0.4"),  # per 1M output tokens
-        context_length=128000,
-        output_length=4096,
-        intelligence=3,
-        speed=5,
-        supports_image_input=False,
-        supports_skill_calls=True,
-        supports_structured_output=True,
-        supports_frequency_penalty=False,
-        supports_presence_penalty=False,
-    ),
-    "gpt-4.1-mini": LLMModelInfo(
-        id="gpt-4.1-mini",
-        name="GPT-4.1 Mini",
-        provider=LLMProvider.OPENAI,
-        input_price=Decimal("0.4"),  # per 1M input tokens
-        output_price=Decimal("1.6"),  # per 1M output tokens
-        context_length=128000,
-        output_length=4096,
-        intelligence=4,
-        speed=4,
-        supports_image_input=False,
-        supports_skill_calls=True,
-        supports_structured_output=True,
-        supports_search=True,
-        supports_frequency_penalty=False,
-        supports_presence_penalty=False,
-    ),
-    "gpt-4.1": LLMModelInfo(
-        id="gpt-4.1",
-        name="GPT-4.1",
-        provider=LLMProvider.OPENAI,
-        input_price=Decimal("2.00"),  # per 1M input tokens
-        output_price=Decimal("8.00"),  # per 1M output tokens
-        context_length=128000,
-        output_length=4096,
-        intelligence=5,
-        speed=3,
-        supports_image_input=True,
-        supports_skill_calls=True,
-        supports_structured_output=True,
-        supports_search=True,
-        supports_frequency_penalty=False,
-        supports_presence_penalty=False,
-    ),
-    "o4-mini": LLMModelInfo(
-        id="o4-mini",
-        name="OpenAI o4-mini",
-        provider=LLMProvider.OPENAI,
-        input_price=Decimal("1.10"),  # per 1M input tokens
-        output_price=Decimal("4.40"),  # per 1M output tokens
-        context_length=128000,
-        output_length=4096,
-        intelligence=4,
-        speed=3,
-        supports_image_input=False,
-        supports_skill_calls=True,
-        supports_structured_output=True,
-        has_reasoning=True,  # Has strong reasoning capabilities
-        supports_temperature=False,
-        supports_frequency_penalty=False,
-        supports_presence_penalty=False,
-    ),
-    # Deepseek models
-    "deepseek-chat": LLMModelInfo(
-        id="deepseek-chat",
-        name="Deepseek V3 (0324)",
-        provider=LLMProvider.DEEPSEEK,
-        input_price=Decimal("0.27"),
-        output_price=Decimal("1.10"),
-        context_length=60000,
-        output_length=4096,
-        intelligence=4,
-        speed=3,
-        supports_image_input=False,
-        supports_skill_calls=True,
-        supports_structured_output=True,
-        api_base="https://api.deepseek.com",
-        timeout=300,
-    ),
-    "deepseek-reasoner": LLMModelInfo(
-        id="deepseek-reasoner",
-        name="Deepseek R1",
-        provider=LLMProvider.DEEPSEEK,
-        input_price=Decimal("0.55"),
-        output_price=Decimal("2.19"),
-        context_length=60000,
-        output_length=4096,
-        intelligence=4,
-        speed=2,
-        supports_image_input=False,
-        supports_skill_calls=True,
-        supports_structured_output=True,
-        has_reasoning=True,  # Has strong reasoning capabilities
-        api_base="https://api.deepseek.com",
-        timeout=300,
-    ),
-    # XAI models
-    "grok-2": LLMModelInfo(
-        id="grok-2",
-        name="Grok 2",
-        provider=LLMProvider.XAI,
-        input_price=Decimal("2"),
-        output_price=Decimal("10"),
-        context_length=120000,
-        output_length=4096,
-        intelligence=3,
-        speed=3,
-        supports_image_input=False,
-        supports_skill_calls=True,
-        supports_structured_output=True,
-        timeout=180,
-    ),
-    "grok-3": LLMModelInfo(
-        id="grok-3",
-        name="Grok 3",
-        provider=LLMProvider.XAI,
-        input_price=Decimal("3"),
-        output_price=Decimal("15"),
-        context_length=131072,
-        output_length=4096,
-        intelligence=5,
-        speed=3,
-        supports_image_input=False,
-        supports_skill_calls=True,
-        supports_structured_output=True,
-        supports_search=True,
-        timeout=180,
-    ),
-    "grok-3-mini": LLMModelInfo(
-        id="grok-3-mini",
-        name="Grok 3 Mini",
-        provider=LLMProvider.XAI,
-        input_price=Decimal("0.3"),
-        output_price=Decimal("0.5"),
-        context_length=131072,
-        output_length=4096,
-        intelligence=5,
-        speed=3,
-        supports_image_input=False,
-        supports_skill_calls=True,
-        supports_structured_output=True,
-        has_reasoning=True,  # Has strong reasoning capabilities
-        supports_frequency_penalty=False,
-        supports_presence_penalty=False,  # Grok-3-mini doesn't support presence_penalty
-        timeout=180,
-    ),
-    # Eternal AI models
-    "eternalai": LLMModelInfo(
-        id="eternalai",
-        name="Eternal AI (Llama-3.3-70B)",
-        provider=LLMProvider.ETERNAL,
-        input_price=Decimal("0.25"),
-        output_price=Decimal("0.75"),
-        context_length=60000,
-        output_length=4096,
-        intelligence=4,
-        speed=3,
-        supports_image_input=False,
-        supports_skill_calls=True,
-        supports_structured_output=True,
-        api_base="https://api.eternalai.org/v1",
-        timeout=300,
-    ),
-    # Reigent models
-    "reigent": LLMModelInfo(
-        id="reigent",
-        name="REI Network",
-        provider=LLMProvider.REIGENT,
-        input_price=Decimal("0.50"),  # Placeholder price, update with actual pricing
-        output_price=Decimal("1.50"),  # Placeholder price, update with actual pricing
-        context_length=32000,
-        output_length=4096,
-        intelligence=4,
-        speed=3,
-        supports_image_input=False,
-        supports_skill_calls=True,
-        supports_structured_output=True,
-        supports_temperature=False,
-        supports_frequency_penalty=False,
-        supports_presence_penalty=False,
-        api_base="https://api.reisearch.box/v1",
-        timeout=300,
-    ),
-    # Venice models
-    "venice-uncensored": LLMModelInfo(
-        id="venice-uncensored",
-        name="Venice Uncensored",
-        provider=LLMProvider.VENICE,
-        input_price=Decimal("0.50"),  # Placeholder price, update with actual pricing
-        output_price=Decimal("2.00"),  # Placeholder price, update with actual pricing
-        context_length=32000,
-        output_length=4096,
-        intelligence=3,
-        speed=3,
-        supports_image_input=False,
-        supports_skill_calls=True,
-        supports_structured_output=True,
-        supports_temperature=True,
-        supports_frequency_penalty=False,
-        supports_presence_penalty=False,
-        api_base="https://api.venice.ai/api/v1",
-        timeout=300,
-    ),
-    "venice-llama-4-maverick-17b": LLMModelInfo(
-        id="venice-llama-4-maverick-17b",
-        name="Venice Llama-4 Maverick 17B",
-        provider=LLMProvider.VENICE,
-        input_price=Decimal("1.50"),
-        output_price=Decimal("6.00"),
-        context_length=32000,
-        output_length=4096,
-        intelligence=3,
-        speed=3,
-        supports_image_input=False,
-        supports_skill_calls=True,
-        supports_structured_output=True,
-        supports_temperature=True,
-        supports_frequency_penalty=False,
-        supports_presence_penalty=False,
-        api_base="https://api.venice.ai/api/v1",
-        timeout=300,
-    ),
-}
+        ).quantize(FOURPLACES, rounding=ROUND_HALF_UP)
+        return (input_cost + output_cost).quantize(FOURPLACES, rounding=ROUND_HALF_UP)
+
+
+# Default models loaded from CSV
+AVAILABLE_MODELS = _load_default_llm_models()
 
 
 class LLMModel(BaseModel):
@@ -562,14 +342,14 @@ class LLMModel(BaseModel):
     async def model_info(self) -> LLMModelInfo:
         """Get the model information with caching.
 
-        First tries to get from cache, then database, then AVAILABLE_MODELS.
+        First tries to get from cache, then database, then default models loaded from CSV.
         Raises ValueError if model is not found anywhere.
         """
         model_info = await LLMModelInfo.get(self.model_name)
         return model_info
 
     # This will be implemented by subclasses to return the appropriate LLM instance
-    async def create_instance(self, config: Any) -> LanguageModelLike:
+    async def create_instance(self, params: dict[str, Any] = {}) -> BaseChatModel:
         """Create and return the LLM instance based on the configuration."""
         raise NotImplementedError("Subclasses must implement create_instance")
 
@@ -587,7 +367,7 @@ class LLMModel(BaseModel):
 class OpenAILLM(LLMModel):
     """OpenAI LLM configuration."""
 
-    async def create_instance(self, config: Any) -> LanguageModelLike:
+    async def create_instance(self, params: dict[str, Any] = {}) -> BaseChatModel:
         """Create and return a ChatOpenAI instance."""
         from langchain_openai import ChatOpenAI
 
@@ -612,6 +392,14 @@ class OpenAILLM(LLMModel):
         if info.api_base:
             kwargs["openai_api_base"] = info.api_base
 
+        if self.model_name.startswith("gpt-5-"):
+            kwargs["reasoning_effort"] = "minimal"
+        elif self.model_name == "gpt-5":
+            kwargs["reasoning_effort"] = "low"
+
+        # Update kwargs with params to allow overriding
+        kwargs.update(params)
+
         logger.debug(f"Creating ChatOpenAI instance with kwargs: {kwargs}")
 
         return ChatOpenAI(**kwargs)
@@ -620,7 +408,7 @@ class OpenAILLM(LLMModel):
 class DeepseekLLM(LLMModel):
     """Deepseek LLM configuration."""
 
-    async def create_instance(self, config: Any) -> LanguageModelLike:
+    async def create_instance(self, params: dict[str, Any] = {}) -> BaseChatModel:
         """Create and return a ChatDeepseek instance."""
 
         from langchain_deepseek import ChatDeepSeek
@@ -647,13 +435,16 @@ class DeepseekLLM(LLMModel):
         if info.api_base:
             kwargs["api_base"] = info.api_base
 
+        # Update kwargs with params to allow overriding
+        kwargs.update(params)
+
         return ChatDeepSeek(**kwargs)
 
 
 class XAILLM(LLMModel):
     """XAI (Grok) LLM configuration."""
 
-    async def create_instance(self, config: Any) -> LanguageModelLike:
+    async def create_instance(self, params: dict[str, Any] = {}) -> BaseChatModel:
         """Create and return a ChatXAI instance."""
 
         from langchain_xai import ChatXAI
@@ -676,16 +467,49 @@ class XAILLM(LLMModel):
         if info.supports_presence_penalty:
             kwargs["presence_penalty"] = self.presence_penalty
 
-        if self.model_name in ["grok-3", "grok-3-mini"]:
-            kwargs["search_parameters"] = {"mode": "auto"}
+        # Update kwargs with params to allow overriding
+        kwargs.update(params)
 
         return ChatXAI(**kwargs)
 
 
+class GatewayzLLM(LLMModel):
+    """Gatewayz AI LLM configuration."""
+
+    async def create_instance(self, params: dict[str, Any] = {}) -> BaseChatModel:
+        """Create and return a ChatOpenAI instance configured for Eternal AI."""
+        from langchain_openai import ChatOpenAI
+
+        info = await self.model_info()
+
+        kwargs = {
+            "model": self.model_name,
+            "api_key": config.gatewayz_api_key,
+            "base_url": info.api_base,
+            "timeout": info.timeout,
+            "max_completion_tokens": 999,
+        }
+
+        # Add optional parameters based on model support
+        if info.supports_temperature:
+            kwargs["temperature"] = self.temperature
+
+        if info.supports_frequency_penalty:
+            kwargs["frequency_penalty"] = self.frequency_penalty
+
+        if info.supports_presence_penalty:
+            kwargs["presence_penalty"] = self.presence_penalty
+
+        # Update kwargs with params to allow overriding
+        kwargs.update(params)
+
+        return ChatOpenAI(**kwargs)
+
+
 class EternalLLM(LLMModel):
     """Eternal AI LLM configuration."""
 
-    async def create_instance(self, config: Any) -> LanguageModelLike:
+    async def create_instance(self, params: dict[str, Any] = {}) -> BaseChatModel:
         """Create and return a ChatOpenAI instance configured for Eternal AI."""
         from langchain_openai import ChatOpenAI
 
@@ -711,13 +535,16 @@ class EternalLLM(LLMModel):
         if info.supports_presence_penalty:
             kwargs["presence_penalty"] = self.presence_penalty
 
+        # Update kwargs with params to allow overriding
+        kwargs.update(params)
+
         return ChatOpenAI(**kwargs)
 
 
 class ReigentLLM(LLMModel):
     """Reigent LLM configuration."""
 
-    async def create_instance(self, config: Any) -> LanguageModelLike:
+    async def create_instance(self, params: dict[str, Any] = {}) -> BaseChatModel:
         """Create and return a ChatOpenAI instance configured for Reigent."""
         from langchain_openai import ChatOpenAI
 
@@ -733,13 +560,16 @@ class ReigentLLM(LLMModel):
             },
         }
 
+        # Update kwargs with params to allow overriding
+        kwargs.update(params)
+
         return ChatOpenAI(**kwargs)
 
 
 class VeniceLLM(LLMModel):
     """Venice LLM configuration."""
 
-    async def create_instance(self, config: Any) -> LanguageModelLike:
+    async def create_instance(self, params: dict[str, Any] = {}) -> BaseChatModel:
         """Create and return a ChatOpenAI instance configured for Venice."""
         from langchain_openai import ChatOpenAI
 
@@ -751,6 +581,9 @@ class VeniceLLM(LLMModel):
             "timeout": info.timeout,
         }
 
+        # Update kwargs with params to allow overriding
+        kwargs.update(params)
+
         return ChatOpenAI(**kwargs)
 
 
@@ -795,6 +628,8 @@ async def create_llm_model(
         return ReigentLLM(**base_params)
     elif provider == LLMProvider.VENICE:
         return VeniceLLM(**base_params)
+    elif provider == LLMProvider.GATEWAYZ:
+        return GatewayzLLM(**base_params)
     else:
         # Default to OpenAI
         return OpenAILLM(**base_params)