fix(oci): uppercase tool type field for OCI V2 API compatibility (#758)

* fix(oci): uppercase tool type field for OCI V2 API compatibility

OCI Generative AI expects tool type as "FUNCTION" (uppercase) but the
SDK passes through the Cohere format "function" (lowercase), causing
a 400 error. Transform tool types to uppercase like we do for message
roles and content types.

* test(oci): add integration test for tool use on OCI on-demand

The missing integration test allowed the tool type casing bug to
ship undetected. This test calls OCI with a tool definition and
verifies the response contains tool_calls with the correct function
name and arguments.

* fix(oci): complete casing audit for OCI field transformations

Fix remaining casing issues found during systematic audit:

- V1 tools: uppercase type field (same fix as V2)
- tool_calls in messages: uppercase type when sending tool results back
  in multi-turn conversations
- Response tool_calls: lowercase type from OCI's "FUNCTION" back to
  "function" for Cohere SDK compatibility
- safety_mode: uppercase defensively (CONTEXTUAL/STRICT/OFF)

Integration tests added for each:
- test_chat_tool_use_response_type_lowered: verifies tool_call.type
  is "function" (not "FUNCTION") in responses
- test_chat_multi_turn_tool_use_v2: full tool use round-trip (call →
  result → final response)
- test_chat_safety_mode_v2: verifies safety_mode works on OCI

* fix(oci): fix embed embedding_types casing and handle embeddingsByType response

- embedding_types: OCI expects lowercase (float, int8) not uppercase.
  The .upper() was breaking all embedding_types requests.
- Response: OCI returns "embeddingsByType" (not "embeddings") when
  embeddingTypes is specified. Handle both response keys.
- Unit test updated to expect lowercase.
- Integration tests added: embedding_types=["float"] and truncate modes.

* fix(oci): guard safety_mode.upper() against None value

Address Cursor Bugbot review: safety_mode is Optional, so the SDK can
pass None when the user explicitly sets safety_mode=None. Guard with
a None check before calling .upper() on both V1 and V2 paths.

Author: fede-kamel

src/cohere/oci_client.py

@@ -669,7 +669,8 @@ def transform_request_to_oci(
             oci_body["truncate"] = cohere_body["truncate"].upper()
 
         if "embedding_types" in cohere_body:
-            oci_body["embeddingTypes"] = [et.upper() for et in cohere_body["embedding_types"]]
+            # OCI expects lowercase embedding types (float, int8, binary, etc.)
+            oci_body["embeddingTypes"] = [et.lower() for et in cohere_body["embedding_types"]]
         if "max_tokens" in cohere_body:
             oci_body["maxTokens"] = cohere_body["max_tokens"]
         if "output_dimension" in cohere_body:
@@ -728,7 +729,13 @@ def transform_request_to_oci(
                     oci_msg["content"] = msg.get("content") or []
 
                 if "tool_calls" in msg:
-                    oci_msg["toolCalls"] = msg["tool_calls"]
+                    oci_tool_calls = []
+                    for tc in msg["tool_calls"]:
+                        oci_tc = {**tc}
+                        if "type" in oci_tc:
+                            oci_tc["type"] = oci_tc["type"].upper()
+                        oci_tool_calls.append(oci_tc)
+                    oci_msg["toolCalls"] = oci_tool_calls
                 if "tool_call_id" in msg:
                     oci_msg["toolCallId"] = msg["tool_call_id"]
                 if "tool_plan" in msg:
@@ -756,7 +763,13 @@ def transform_request_to_oci(
             if "stop_sequences" in cohere_body:
                 chat_request["stopSequences"] = cohere_body["stop_sequences"]
             if "tools" in cohere_body:
-                chat_request["tools"] = cohere_body["tools"]
+                oci_tools = []
+                for tool in cohere_body["tools"]:
+                    oci_tool = {**tool}
+                    if "type" in oci_tool:
+                        oci_tool["type"] = oci_tool["type"].upper()
+                    oci_tools.append(oci_tool)
+                chat_request["tools"] = oci_tools
             if "strict_tools" in cohere_body:
                 chat_request["strictTools"] = cohere_body["strict_tools"]
             if "documents" in cohere_body:
@@ -765,8 +778,8 @@ def transform_request_to_oci(
                 chat_request["citationOptions"] = cohere_body["citation_options"]
             if "response_format" in cohere_body:
                 chat_request["responseFormat"] = cohere_body["response_format"]
-            if "safety_mode" in cohere_body:
-                chat_request["safetyMode"] = cohere_body["safety_mode"]
+            if "safety_mode" in cohere_body and cohere_body["safety_mode"] is not None:
+                chat_request["safetyMode"] = cohere_body["safety_mode"].upper()
             if "logprobs" in cohere_body:
                 chat_request["logprobs"] = cohere_body["logprobs"]
             if "tool_choice" in cohere_body:
@@ -810,13 +823,19 @@ def transform_request_to_oci(
             if "documents" in cohere_body:
                 chat_request["documents"] = cohere_body["documents"]
             if "tools" in cohere_body:
-                chat_request["tools"] = cohere_body["tools"]
+                oci_tools = []
+                for tool in cohere_body["tools"]:
+                    oci_tool = {**tool}
+                    if "type" in oci_tool:
+                        oci_tool["type"] = oci_tool["type"].upper()
+                    oci_tools.append(oci_tool)
+                chat_request["tools"] = oci_tools
             if "tool_results" in cohere_body:
                 chat_request["toolResults"] = cohere_body["tool_results"]
             if "response_format" in cohere_body:
                 chat_request["responseFormat"] = cohere_body["response_format"]
-            if "safety_mode" in cohere_body:
-                chat_request["safetyMode"] = cohere_body["safety_mode"]
+            if "safety_mode" in cohere_body and cohere_body["safety_mode"] is not None:
+                chat_request["safetyMode"] = cohere_body["safety_mode"].upper()
             if "priority" in cohere_body:
                 chat_request["priority"] = cohere_body["priority"]
 
@@ -857,7 +876,8 @@ def transform_oci_response_to_cohere(
         Transformed response in Cohere format
     """
     if endpoint == "embed":
-        embeddings_data = oci_response.get("embeddings", {})
+        # OCI returns "embeddings" by default, or "embeddingsByType" when embeddingTypes is specified
+        embeddings_data = oci_response.get("embeddingsByType") or oci_response.get("embeddings", {})
 
         if isinstance(embeddings_data, dict):
             normalized_embeddings = {str(key).lower(): value for key, value in embeddings_data.items()}
@@ -911,7 +931,12 @@ def transform_oci_response_to_cohere(
                 message = {**message, "content": transformed_content}
 
             if "toolCalls" in message:
-                tool_calls = message["toolCalls"]
+                tool_calls = []
+                for tc in message["toolCalls"]:
+                    lowered_tc = {**tc}
+                    if "type" in lowered_tc:
+                        lowered_tc["type"] = lowered_tc["type"].lower()
+                    tool_calls.append(lowered_tc)
                 message = {k: v for k, v in message.items() if k != "toolCalls"}
                 message["tool_calls"] = tool_calls
             if "toolPlan" in message:

tests/test_oci_client.py

@@ -190,6 +190,135 @@ def test_chat_v2(self):
         self.assertIsNotNone(response)
         self.assertIsNotNone(response.message)
 
+    def test_chat_tool_use_v2(self):
+        """Test tool use with v2 client on OCI on-demand inference."""
+        response = self.client.chat(
+            model="command-a-03-2025",
+            messages=[{"role": "user", "content": "What's the weather in Toronto?"}],
+            max_tokens=200,
+            tools=[{
+                "type": "function",
+                "function": {
+                    "name": "get_weather",
+                    "description": "Get current weather for a location",
+                    "parameters": {
+                        "type": "object",
+                        "properties": {
+                            "location": {"type": "string", "description": "City name"}
+                        },
+                        "required": ["location"],
+                    },
+                },
+            }],
+        )
+
+        self.assertIsNotNone(response)
+        self.assertIsNotNone(response.message)
+        self.assertEqual(response.finish_reason, "TOOL_CALL")
+        self.assertTrue(len(response.message.tool_calls) > 0)
+        tool_call = response.message.tool_calls[0]
+        self.assertEqual(tool_call.function.name, "get_weather")
+        self.assertIn("Toronto", tool_call.function.arguments)
+
+    def test_chat_tool_use_response_type_lowered(self):
+        """Test that tool_call type is lowercased in response (OCI returns FUNCTION)."""
+        response = self.client.chat(
+            model="command-a-03-2025",
+            messages=[{"role": "user", "content": "What's the weather in Toronto?"}],
+            max_tokens=200,
+            tools=[{
+                "type": "function",
+                "function": {
+                    "name": "get_weather",
+                    "description": "Get current weather for a location",
+                    "parameters": {
+                        "type": "object",
+                        "properties": {
+                            "location": {"type": "string", "description": "City name"}
+                        },
+                        "required": ["location"],
+                    },
+                },
+            }],
+        )
+
+        self.assertEqual(response.finish_reason, "TOOL_CALL")
+        tool_call = response.message.tool_calls[0]
+        # OCI returns "FUNCTION" — SDK must lowercase to "function" for Cohere compat
+        self.assertEqual(tool_call.type, "function")
+
+    def test_chat_multi_turn_tool_use_v2(self):
+        """Test multi-turn tool use: send tool result back after tool call."""
+        # Step 1: Get a tool call
+        response = self.client.chat(
+            model="command-a-03-2025",
+            messages=[{"role": "user", "content": "What's the weather in Toronto?"}],
+            max_tokens=200,
+            tools=[{
+                "type": "function",
+                "function": {
+                    "name": "get_weather",
+                    "description": "Get current weather for a location",
+                    "parameters": {
+                        "type": "object",
+                        "properties": {
+                            "location": {"type": "string", "description": "City name"}
+                        },
+                        "required": ["location"],
+                    },
+                },
+            }],
+        )
+        self.assertEqual(response.finish_reason, "TOOL_CALL")
+        tool_call = response.message.tool_calls[0]
+
+        # Step 2: Send tool result back
+        response2 = self.client.chat(
+            model="command-a-03-2025",
+            messages=[
+                {"role": "user", "content": "What's the weather in Toronto?"},
+                {
+                    "role": "assistant",
+                    "tool_calls": [{"id": tool_call.id, "type": "function", "function": {"name": "get_weather", "arguments": tool_call.function.arguments}}],
+                    "tool_plan": response.message.tool_plan,
+                },
+                {
+                    "role": "tool",
+                    "tool_call_id": tool_call.id,
+                    "content": [{"type": "text", "text": "15°C, sunny"}],
+                },
+            ],
+            max_tokens=200,
+            tools=[{
+                "type": "function",
+                "function": {
+                    "name": "get_weather",
+                    "description": "Get current weather for a location",
+                    "parameters": {
+                        "type": "object",
+                        "properties": {
+                            "location": {"type": "string", "description": "City name"}
+                        },
+                        "required": ["location"],
+                    },
+                },
+            }],
+        )
+
+        self.assertIsNotNone(response2.message)
+        # Model should respond with text incorporating the tool result
+        self.assertTrue(len(response2.message.content) > 0)
+
+    def test_chat_safety_mode_v2(self):
+        """Test that safety_mode is uppercased for OCI."""
+        # Cohere SDK enum values are already uppercase, but test lowercase too
+        response = self.client.chat(
+            model="command-a-03-2025",
+            messages=[{"role": "user", "content": "Say hi"}],
+            safety_mode="STRICT",
+        )
+        self.assertIsNotNone(response.message)
+
     def test_chat_stream_v2(self):
         """Test V2 streaming chat terminates and produces correct event lifecycle."""
         events = []
@@ -389,6 +518,30 @@ def test_embed_search_query_input_type(self):
         self.assertIsNotNone(response.embeddings.float_)
         self.assertEqual(len(response.embeddings.float_[0]), 1024)
 
+    def test_embed_with_embedding_types(self):
+        """Test embed with explicit embedding_types parameter."""
+        response = self.client.embed(
+            model="embed-english-v3.0",
+            texts=["Hello world"],
+            input_type="search_document",
+            embedding_types=["float"],
+        )
+        self.assertIsNotNone(response.embeddings.float_)
+        self.assertEqual(len(response.embeddings.float_[0]), 1024)
+
+    def test_embed_with_truncate(self):
+        """Test embed with truncate parameter."""
+        long_text = "hello " * 1000
+        for mode in ["NONE", "START", "END"]:
+            response = self.client.embed(
+                model="embed-english-v3.0",
+                texts=[long_text],
+                input_type="search_document",
+                truncate=mode,
+            )
+            self.assertIsNotNone(response.embeddings.float_)
+            self.assertEqual(len(response.embeddings.float_[0]), 1024)
+
     def test_command_r_plus_chat(self):
         """Test command-r-plus-08-2024 via V1 client."""
         v1_client = cohere.OciClient(
@@ -652,7 +805,7 @@ def test_transform_embed_request(self):
         self.assertEqual(result["inputs"], ["hello", "world"])
         self.assertEqual(result["inputType"], "SEARCH_DOCUMENT")
         self.assertEqual(result["truncate"], "END")
-        self.assertEqual(result["embeddingTypes"], ["FLOAT", "INT8"])
+        self.assertEqual(result["embeddingTypes"], ["float", "int8"])
         self.assertEqual(result["compartmentId"], "compartment-123")
         self.assertEqual(result["servingMode"]["modelId"], "cohere.embed-english-v3.0")