intentkit 0.7.5.dev3__py3-none-any.whl → 0.8.34.dev7__py3-none-any.whl

intentkit/models/llm.py

@@ -1,18 +1,24 @@
+import csv
 import json
 import logging
-from datetime import datetime, timezone
+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 langchain.chat_models.base import BaseChatModel
+from pydantic import BaseModel, ConfigDict, Field
+from sqlalchemy import Boolean, DateTime, Integer, Numeric, String, func, select
+from sqlalchemy.ext.asyncio import AsyncSession
+from sqlalchemy.orm import Mapped, mapped_column
+
+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 pydantic import BaseModel, ConfigDict, Field
-from sqlalchemy import Boolean, Column, DateTime, Integer, Numeric, String, func, select
+from intentkit.utils.error import IntentKitAPIError
 
 logger = logging.getLogger(__name__)
 
@@ -20,13 +26,85 @@ _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,
+                )
+                if not model.enabled:
+                    continue
+            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"
+    OLLAMA = "ollama"
 
     def display_name(self) -> str:
         """Return user-friendly display name for the provider."""
@@ -34,9 +112,11 @@ 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",
+            self.OLLAMA: "Ollama",
         }
         return display_names.get(self, self.value)
 
@@ -46,41 +126,63 @@ class LLMModelInfoTable(Base):
 
     __tablename__ = "llm_models"
 
-    id = Column(String, primary_key=True)
-    name = Column(String, nullable=False)
-    provider = Column(String, nullable=False)  # Stored as string enum value
-    enabled = Column(Boolean, nullable=False, default=True)
-    input_price = Column(
+    id: Mapped[str] = mapped_column(String, primary_key=True)
+    name: Mapped[str] = mapped_column(String, nullable=False)
+    provider: Mapped[str] = mapped_column(String, nullable=False)  # Stored as enum
+    enabled: Mapped[bool] = mapped_column(Boolean, nullable=False, default=True)
+    input_price: Mapped[Decimal] = mapped_column(
         Numeric(22, 4), nullable=False
     )  # Price per 1M input tokens in USD
-    output_price = Column(
+    output_price: Mapped[Decimal] = mapped_column(
         Numeric(22, 4), nullable=False
     )  # Price per 1M output tokens in USD
-    price_level = Column(Integer, nullable=True)  # Price level rating from 1-5
-    context_length = Column(Integer, nullable=False)  # Maximum context length in tokens
-    output_length = Column(Integer, nullable=False)  # Maximum output length in tokens
-    intelligence = Column(Integer, nullable=False)  # Intelligence rating from 1-5
-    speed = Column(Integer, nullable=False)  # Speed rating from 1-5
-    supports_image_input = Column(Boolean, nullable=False, default=False)
-    supports_skill_calls = Column(Boolean, nullable=False, default=False)
-    supports_structured_output = Column(Boolean, nullable=False, default=False)
-    has_reasoning = Column(Boolean, nullable=False, default=False)
-    supports_search = Column(Boolean, nullable=False, default=False)
-    supports_temperature = Column(Boolean, nullable=False, default=True)
-    supports_frequency_penalty = Column(Boolean, nullable=False, default=True)
-    supports_presence_penalty = Column(Boolean, nullable=False, default=True)
-    api_base = Column(String, nullable=True)  # Custom API base URL
-    timeout = Column(Integer, nullable=False, default=180)  # Default timeout in seconds
-    created_at = Column(
+    price_level: Mapped[int | None] = mapped_column(
+        Integer, nullable=True
+    )  # Price level rating
+    context_length: Mapped[int] = mapped_column(
+        Integer, nullable=False
+    )  # Context length
+    output_length: Mapped[int] = mapped_column(Integer, nullable=False)  # Output length
+    intelligence: Mapped[int] = mapped_column(
+        Integer, nullable=False
+    )  # Intelligence rating
+    speed: Mapped[int] = mapped_column(Integer, nullable=False)  # Speed rating
+    supports_image_input: Mapped[bool] = mapped_column(
+        Boolean, nullable=False, default=False
+    )
+    supports_skill_calls: Mapped[bool] = mapped_column(
+        Boolean, nullable=False, default=False
+    )
+    supports_structured_output: Mapped[bool] = mapped_column(
+        Boolean, nullable=False, default=False
+    )
+    has_reasoning: Mapped[bool] = mapped_column(Boolean, nullable=False, default=False)
+    supports_search: Mapped[bool] = mapped_column(
+        Boolean, nullable=False, default=False
+    )
+    supports_temperature: Mapped[bool] = mapped_column(
+        Boolean, nullable=False, default=True
+    )
+    supports_frequency_penalty: Mapped[bool] = mapped_column(
+        Boolean, nullable=False, default=True
+    )
+    supports_presence_penalty: Mapped[bool] = mapped_column(
+        Boolean, nullable=False, default=True
+    )
+    api_base: Mapped[str | None] = mapped_column(String, nullable=True)
+    timeout: Mapped[int] = mapped_column(
+        Integer, nullable=False, default=180
+    )  # Timeout seconds
+    created_at: Mapped[datetime] = mapped_column(
         DateTime(timezone=True),
         nullable=False,
         server_default=func.now(),
     )
-    updated_at = Column(
+    updated_at: Mapped[datetime] = mapped_column(
         DateTime(timezone=True),
         nullable=False,
         server_default=func.now(),
-        onupdate=lambda: datetime.now(timezone.utc),
+        onupdate=lambda: datetime.now(UTC),
     )
 
 
@@ -99,7 +201,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
@@ -124,22 +226,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),
         ),
     ]
 
@@ -208,7 +308,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
@@ -230,325 +354,8 @@ class LLMModelInfo(BaseModel):
         return (input_cost + output_cost).quantize(FOURPLACES, rounding=ROUND_HALF_UP)
 
 
-# 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,
-    ),
-}
+# Default models loaded from CSV
+AVAILABLE_MODELS = _load_default_llm_models()
 
 
 class LLMModel(BaseModel):
@@ -563,14 +370,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")
 
@@ -588,7 +395,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
 
@@ -598,6 +405,7 @@ class OpenAILLM(LLMModel):
             "model_name": self.model_name,
             "openai_api_key": config.openai_api_key,
             "timeout": info.timeout,
+            "use_responses_api": True,
         }
 
         # Add optional parameters based on model support
@@ -613,8 +421,13 @@ class OpenAILLM(LLMModel):
         if info.api_base:
             kwargs["openai_api_base"] = info.api_base
 
-        if self.model_name.startswith("gpt-5"):
+        if self.model_name == "gpt-5-mini" or self.model_name == "gpt-5-nano":
             kwargs["reasoning_effort"] = "minimal"
+        elif self.model_name == "gpt-5.1-codex":
+            kwargs["reasoning_effort"] = "high"
+
+        # Update kwargs with params to allow overriding
+        kwargs.update(params)
 
         logger.debug(f"Creating ChatOpenAI instance with kwargs: {kwargs}")
 
@@ -624,7 +437,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
@@ -651,13 +464,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
@@ -680,16 +496,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
 
@@ -715,13 +564,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
 
@@ -737,13 +589,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
 
@@ -755,9 +610,42 @@ class VeniceLLM(LLMModel):
             "timeout": info.timeout,
         }
 
+        # Update kwargs with params to allow overriding
+        kwargs.update(params)
+
         return ChatOpenAI(**kwargs)
 
 
+# Factory function to create the appropriate LLM model based on the model name
+class OllamaLLM(LLMModel):
+    """Ollama LLM configuration."""
+
+    async def create_instance(self, params: dict[str, Any] = {}) -> BaseChatModel:
+        """Create and return a ChatOllama instance."""
+        from langchain_ollama import ChatOllama
+
+        info = await self.model_info()
+
+        kwargs = {
+            "model": self.model_name,
+            "base_url": info.api_base or "http://localhost:11434",
+            "temperature": self.temperature,
+            # Ollama specific parameters
+            "keep_alive": -1,  # Keep the model loaded indefinitely
+        }
+
+        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 ChatOllama(**kwargs)
+
+
 # Factory function to create the appropriate LLM model based on the model name
 async def create_llm_model(
     model_name: str,
@@ -799,6 +687,10 @@ 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)
+    elif provider == LLMProvider.OLLAMA:
+        return OllamaLLM(**base_params)
     else:
         # Default to OpenAI
         return OpenAILLM(**base_params)