oracle
diff --git a/‎.github/scripts/get_min_versions.py‎
Lines changed: 31 additions & 28 deletions b/‎.github/scripts/get_min_versions.py‎
Lines changed: 31 additions & 28 deletions
diff --git a/‎.github/workflows/_test.yml‎
Lines changed: 1 addition & 0 deletions b/‎.github/workflows/_test.yml‎
Lines changed: 1 addition & 0 deletions
diff --git a/‎libs/oci/langchain_oci/chat_models/oci_data_science.py‎
Lines changed: 15 additions & 4 deletions b/‎libs/oci/langchain_oci/chat_models/oci_data_science.py‎
Lines changed: 15 additions & 4 deletions
diff --git a/‎libs/oci/langchain_oci/chat_models/oci_generative_ai.py‎
Lines changed: 7 additions & 5 deletions b/‎libs/oci/langchain_oci/chat_models/oci_generative_ai.py‎
Lines changed: 7 additions & 5 deletions
@@ -47,25 +47,43 @@ def get_min_version_from_toml(toml_path: str):
     # Parse dependencies list into a dictionary
     # Format: "package-name>=x.x.x,<y.y.y" or "package-name>=x.x.x; python_version < '3.10'"
     dependencies = {}
+    python_version = f"{sys.version_info.major}.{sys.version_info.minor}"
+
     for dep in dependencies_list:
-        # Remove environment markers (everything after semicolon)
-        dep_without_marker = dep.split(";")[0].strip()
+        # Check if there's a Python version marker
+        if ";" in dep:
+            dep_without_marker, marker = dep.split(";", 1)
+            dep_without_marker = dep_without_marker.strip()
+            marker = marker.strip()
+
+            # Check if this dependency applies to current Python version
+            # Handle python_version < '3.10' and python_version >= '3.10' markers
+            applies_to_current = True
+            if "python_version" in marker:
+                if "<" in marker and not ">=" in marker:
+                    # python_version < 'X.Y'
+                    match = re.search(r"python_version\s*<\s*['\"](\d+\.\d+)['\"]", marker)
+                    if match:
+                        max_version = match.group(1)
+                        applies_to_current = parse_version(python_version) < parse_version(max_version)
+                elif ">=" in marker:
+                    # python_version >= 'X.Y'
+                    match = re.search(r"python_version\s*>=\s*['\"](\d+\.\d+)['\"]", marker)
+                    if match:
+                        min_version_marker = match.group(1)
+                        applies_to_current = parse_version(python_version) >= parse_version(min_version_marker)
+
+            if not applies_to_current:
+                continue
+        else:
+            dep_without_marker = dep.strip()
 
         # Extract package name and version spec
         match = re.match(r"^([a-zA-Z0-9_-]+)(.*)$", dep_without_marker)
         if match:
             pkg_name = match.group(1)
             version_spec = match.group(2)
-
-            # If this package already exists, collect both version specs
-            if pkg_name in dependencies:
-                # Store as a list to handle multiple version constraints
-                if isinstance(dependencies[pkg_name], list):
-                    dependencies[pkg_name].append(version_spec)
-                else:
-                    dependencies[pkg_name] = [dependencies[pkg_name], version_spec]
-            else:
-                dependencies[pkg_name] = version_spec
+            dependencies[pkg_name] = version_spec
 
     # Initialize a dictionary to store the minimum versions
     min_versions = {}
@@ -74,23 +92,8 @@ def get_min_version_from_toml(toml_path: str):
     for lib in MIN_VERSION_LIBS:
         # Check if the lib is present in the dependencies
         if lib in dependencies:
-            # Get the version string(s)
             version_spec = dependencies[lib]
-
-            # Handle list format (multiple version constraints for different Python versions)
-            if isinstance(version_spec, list):
-                # Extract all version strings from the list and find the minimum
-                versions = []
-                for spec in version_spec:
-                    if spec:
-                        versions.append(get_min_version(spec))
-
-                # If we found versions, use the minimum one
-                if versions:
-                    min_version = min(versions, key=parse_version)
-                    min_versions[lib] = min_version
-            elif isinstance(version_spec, str) and version_spec:
-                # Handle simple string format
+            if version_spec:
                 min_version = get_min_version(version_spec)
                 min_versions[lib] = min_version
 
 
@@ -22,6 +22,7 @@ jobs:
         python-version:
           - "3.9"
           - "3.12"
+          - "3.13"
     name: "make test #${{ matrix.python-version }}"
     steps:
       - uses: actions/checkout@v4
 
@@ -31,7 +31,12 @@
     agenerate_from_stream,
     generate_from_stream,
 )
-from langchain_core.messages import AIMessageChunk, BaseMessage, BaseMessageChunk
+from langchain_core.messages import (
+    AIMessage,
+    AIMessageChunk,
+    BaseMessage,
+    BaseMessageChunk,
+)
 from langchain_core.output_parsers import (
     JsonOutputParser,
     PydanticOutputParser,
@@ -765,11 +770,17 @@ def _process_response(self, response_json: dict) -> ChatResult:
 
     def bind_tools(
         self,
-        tools: Sequence[Union[Dict[str, Any], Type[BaseModel], Callable, BaseTool]],
+        tools: Sequence[Union[Dict[str, Any], type, Callable, BaseTool]],
+        # Type annotation matches LangChain's BaseChatModel API.
+        # Runtime validation occurs in convert_to_openai_tool().
+        *,
+        tool_choice: Optional[str] = None,
         **kwargs: Any,
-    ) -> Runnable[LanguageModelInput, BaseMessage]:
+    ) -> Runnable[LanguageModelInput, AIMessage]:
         formatted_tools = [convert_to_openai_tool(tool) for tool in tools]
-        return super().bind(tools=formatted_tools, **kwargs)
+        if tool_choice is not None:
+            kwargs["tool_choice"] = tool_choice
+        return super().bind(tools=formatted_tools, **kwargs)  # type: ignore[return-value, unused-ignore]
 
 
 class ChatOCIModelDeploymentVLLM(ChatOCIModelDeployment):
 
@@ -1261,14 +1261,16 @@ def _prepare_request(
 
     def bind_tools(
         self,
-        tools: Sequence[Union[Dict[str, Any], Type[BaseModel], Callable, BaseTool]],
+        tools: Sequence[Union[Dict[str, Any], type, Callable, BaseTool]],
+        # Type annotation matches LangChain's BaseChatModel API.
+        # Runtime validation occurs in convert_to_openai_tool().
         *,
         tool_choice: Optional[
             Union[dict, str, Literal["auto", "none", "required", "any"], bool]
         ] = None,
         parallel_tool_calls: Optional[bool] = None,
         **kwargs: Any,
-    ) -> Runnable[LanguageModelInput, BaseMessage]:
+    ) -> Runnable[LanguageModelInput, AIMessage]:
         """Bind tool-like objects to this chat model.
 
         Assumes model is compatible with Meta's tool-calling API.
@@ -1310,7 +1312,7 @@ def bind_tools(
                 )
             kwargs["is_parallel_tool_calls"] = True
 
-        return super().bind(tools=formatted_tools, **kwargs)
+        return super().bind(tools=formatted_tools, **kwargs)  # type: ignore[return-value, unused-ignore]
 
     def with_structured_output(
         self,
@@ -1383,7 +1385,7 @@ def with_structured_output(
                     key_name=tool_name, first_tool_only=True
                 )
         elif method == "json_mode":
-            llm = self.bind(response_format={"type": "JSON_OBJECT"})
+            llm = self.bind(response_format={"type": "JSON_OBJECT"})  # type: ignore[assignment, unused-ignore]
             output_parser = (
                 PydanticOutputParser(pydantic_object=schema)
                 if is_pydantic_schema
@@ -1410,7 +1412,7 @@ def with_structured_output(
                 json_schema=response_json_schema
             )
 
-            llm = self.bind(response_format=response_format_obj)
+            llm = self.bind(response_format=response_format_obj)  # type: ignore[assignment, unused-ignore]
             if is_pydantic_schema:
                 output_parser = PydanticOutputParser(pydantic_object=schema)
             else: