Bump to 1.1.0 - Added ability to choose model provider when declaring conditions (#6)

Author: segfly

.vscode/settings.json

@@ -94,6 +94,7 @@
     "editor.suggest.localityBonus": true,
     "editor.inlineSuggest.showToolbar": "onHover",
 
+    "chat.agent.enabled": true,
     "github.copilot.chat.generateTests.codeLens": true,
-    "github.copilot.nextEditSuggestions.enabled": true,
+    "github.copilot.nextEditSuggestions.enabled": false
 }

poetry.lock

@@ -20,7 +20,7 @@ requires = ["poetry-core"]
 build-backend = "poetry.core.masonry.api"
 
 [tool.poetry]
-version = "1.0.0" # Update manually, or use plugin
+version = "1.1.0" # Update manually, or use plugin
 packages = [{ include = "vulcan_core", from="src" }]
 requires-poetry = "~2.1.1"
 classifiers = [
@@ -84,6 +84,9 @@ pydantic = "~2.10.6"
 langchain = { version = "~0.3.20", optional = true } 
 langchain-openai = { version = "~0.3.9", optional = true }
 
+[tool.poetry.extras]
+openai = ["langchain", "langchain-openai"]
+
 [project.optional-dependencies]
 openai = ["langchain", "langchain-openai"]
 

pyproject.toml

@@ -152,16 +152,35 @@ def _extract_lambda_source(self) -> str:
             raise ASTProcessingError(msg)
 
         # The source includes the entire line of code (e.g., assignment and condition() call)
-        # We need to parse parentheses to extract just the lambda expression, handling any
-        # nested parentheses in the lambda's body correctly
+        # We need to extract just the lambda expression, handling nested structures correctly
         source = self.source[lambda_start:]
+
+        # Track depth of various brackets to ensure we don't split inside valid nested structures apart from trailing
+        # arguments within the condition() call
         paren_level = 0
+        bracket_level = 0
+        brace_level = 0
+
         for i, char in enumerate(source):
             if char == "(":
                 paren_level += 1
-            elif char == ")" and paren_level > 0:
-                paren_level -= 1
-            elif char == ")" and paren_level == 0:
+            elif char == ")":
+                if paren_level > 0:
+                    paren_level -= 1
+                elif paren_level == 0:  # End of expression in a function call
+                    return source[:i]
+            elif char == "[":
+                bracket_level += 1
+            elif char == "]":
+                if bracket_level > 0:
+                    bracket_level -= 1
+            elif char == "{":
+                brace_level += 1
+            elif char == "}":
+                if brace_level > 0:
+                    brace_level -= 1
+            # Only consider comma as a separator when not inside any brackets
+            elif char == "," and paren_level == 0 and bracket_level == 0 and brace_level == 0:
                 return source[:i]
 
         return source

src/vulcan_core/ast_utils.py

@@ -8,11 +8,11 @@
 from abc import abstractmethod
 from dataclasses import dataclass, field
 from enum import Enum, auto
+from functools import lru_cache
 from string import Formatter
 from typing import TYPE_CHECKING
 
 from langchain.prompts import ChatPromptTemplate
-from langchain_openai import ChatOpenAI
 from pydantic import BaseModel, Field
 
 from vulcan_core.actions import ASTProcessor
@@ -22,6 +22,11 @@
     from langchain_core.language_models import BaseChatModel
     from langchain_core.runnables import RunnableSerializable
 
+import importlib.util
+import logging
+
+logger = logging.getLogger(__name__)
+
 
 @dataclass(frozen=True, slots=True)
 class Expression(DeclaresFacts):
@@ -182,6 +187,7 @@ def get_field(self, field_name, args, kwargs):
 @dataclass(frozen=True, slots=True)
 class AICondition(Condition):
     chain: RunnableSerializable
+    model: BaseChatModel
     system_template: str
     inquiry_template: str
     func: None = field(init=False, default=None)
@@ -238,13 +244,23 @@ def ai_condition(model: BaseChatModel, inquiry: str) -> AICondition:
     )
     structured_model = model.with_structured_output(BooleanDecision)
     chain = prompt_template | structured_model
-    return AICondition(chain=chain, system_template=system, inquiry_template=inquiry, facts=facts)
+    return AICondition(chain=chain, model=model, system_template=system, inquiry_template=inquiry, facts=facts)
 
 
-default_model = ChatOpenAI(model="gpt-4o-mini", temperature=0, max_tokens=100)  # type: ignore[call-arg] - pyright can't see the args for some reason
+@lru_cache(maxsize=1)
+def _detect_default_model() -> BaseChatModel:
+    # TODO: Expand this to detect other providers
+    if importlib.util.find_spec("langchain_openai"):
+        from langchain_openai import ChatOpenAI
+
+        logger.debug("Using OpenAI as the default LLM model provider.")
+        return ChatOpenAI(model="gpt-4o-mini", temperature=0, max_tokens=100)  # type: ignore[call-arg] - pyright can't see the args for some reason
+    else:
+        msg = "Unable to import a default LLM provider. Please install `vulcan_core` with the approriate extras package or specify your custom model explicitly."
+        raise ImportError(msg)
 
 
-def condition(func: ConditionCallable | str) -> Condition:
+def condition(func: ConditionCallable | str, model: BaseChatModel | None  = None) -> Condition:
     """
     Creates a Condition object from a lambda or function. It performs limited static analysis of the code to ensure
     proper usage and discover the facts/attributes accessed by the condition. This allows the rule engine to track
@@ -284,10 +300,14 @@ def is_user_adult(user: User) -> bool:
     """
 
     if not isinstance(func, str):
+        # Logic condition assumed, ignore kwargs
         processed = ASTProcessor[ConditionCallable](func, condition, bool)
         return Condition(processed.facts, processed.func)
     else:
-        return ai_condition(default_model, func)
+        # AI condition assumed
+        if not model:
+            model = _detect_default_model()
+        return ai_condition(model, func)
 
 
 # TODO: Create a convenience function for creating OnFactChanged conditions

src/vulcan_core/conditions.py

@@ -258,3 +258,6 @@ def __iter__(self) -> str:
 
     def __len__(self) -> int:
         raise NotImplementedError
+
+    def __str__(self) -> str:
+        return f"RetrieverAdapter(search_type={self.store.search_type})"

src/vulcan_core/models.py

@@ -1,6 +1,9 @@
 # SPDX-License-Identifier: Apache-2.0
 # Copyright 2025 Latchfield Technologies http://latchfield.com
 
+from functools import partial
+from unittest.mock import Mock
+
 import pytest
 from langchain_core.language_models import BaseChatModel
 from langchain_openai import ChatOpenAI
@@ -108,8 +111,34 @@ def test_ai_simple_condition_true(model: BaseChatModel, fact_a_instance: FactA,
     assert cond(fact_a_instance, fact_b_instance) is True
 
 
+@pytest.mark.integration
 def test_ai_missing_fact(model: BaseChatModel):
     # TODO: Determine the difference between tool calls and non-tool calls
     # We shouldn't raise an exception if tools are being used
     with pytest.raises(MissingFactError):
         ai_condition(model, "Is the sky blue?")
+
+
+@pytest.mark.integration
+def test_aicondition_with_custom_model(model: BaseChatModel, fact_a_instance: FactA, fact_b_instance: FactB):
+    cond = condition(f"Are {FactA.feature} and {FactB.feature} both on the same planet?", model=model)
+
+    assert set(cond.facts) == {"FactA.feature", "FactB.feature"}
+    assert cond(fact_a_instance, fact_b_instance) is False
+
+
+def test_condition_with_custom_model(foo_instance: Foo, bar_instance: Bar):
+    model = Mock()
+    condition(lambda: Foo.baz and Bar.biz, model=model)
+
+
+def test_aicondition_model_override():
+    model1 = Mock()
+    model2 = Mock()
+
+    custom_condition = partial(condition, model=model1)
+
+    cond1 = custom_condition(f"Are {FactA.feature} and {FactB.feature} both on the same planet?")
+    cond2 = custom_condition(f"Are {FactA.feature} and {FactB.feature} both on the same planet?", model=model2)
+
+    assert cond1.model != cond2.model  # type: ignore