refactor: address Credo issues and improve code readability

- Remove explicit try structures in favor of implicit ones
- Refactor validate_tool_parameters to reduce nesting depth
- Update Elixir version requirement to be less restrictive

Author: madawei2699

lib/llm_agent/handlers.ex

@@ -380,45 +380,61 @@ defmodule LLMAgent.Handlers do
   defp validate_tool_parameters(args, schema) do
     # Implementation of JSON Schema validation
     # This is a simplified version, in production would use a proper validator
-    try do
-      # Check required fields
-      required = Map.get(schema, "required", [])
-      missing_fields = Enum.filter(required, fn field -> is_nil(Map.get(args, field)) end)
+    with {:ok, _} <- validate_required_fields(args, schema),
+         {:ok, _} <- validate_field_types(args, schema) do
+      {:ok, args}
+    end
+  rescue
+    e -> {:error, %{validation_error: Exception.message(e)}}
+  end
 
-      if length(missing_fields) > 0 do
-        {:error, %{missing_required: missing_fields}}
-      else
-        # Validate types if properties defined
-        properties = Map.get(schema, "properties", %{})
-
-        validation_errors =
-          Enum.reduce(properties, %{}, fn {field, field_schema}, errors ->
-            value = Map.get(args, field)
-
-            if is_nil(value) do
-              # Skip validation for optional fields that are not provided
-              errors
-            else
-              # Validate field type
-              expected_type = Map.get(field_schema, "type")
-              actual_type = determine_json_type(value)
-
-              if expected_type != actual_type do
-                Map.put(errors, field, "expected #{expected_type}, got #{actual_type}")
-              else
-                errors
-              end
-            end
-          end)
+  # Validate that all required fields are present
+  defp validate_required_fields(args, schema) do
+    required = Map.get(schema, "required", [])
+    missing_fields = Enum.filter(required, fn field -> is_nil(Map.get(args, field)) end)
 
-        if map_size(validation_errors) > 0 do
-          {:error, %{type_mismatch: validation_errors}}
-        else
-          {:ok, args}
-        end
+    if length(missing_fields) > 0 do
+      {:error, %{missing_required: missing_fields}}
+    else
+      {:ok, args}
+    end
+  end
+
+  # Validate field types against schema
+  defp validate_field_types(args, schema) do
+    properties = Map.get(schema, "properties", %{})
+    validation_errors = check_field_types(args, properties)
+
+    if map_size(validation_errors) > 0 do
+      {:error, %{type_mismatch: validation_errors}}
+    else
+      {:ok, args}
+    end
+  end
+
+  # Helper to check types of all fields
+  defp check_field_types(args, properties) do
+    Enum.reduce(properties, %{}, fn {field, field_schema}, errors ->
+      value = Map.get(args, field)
+
+      if is_nil(value) do
+        # Skip validation for optional fields that are not provided
+        errors
+      else
+        validate_field_type(field, field_schema, value, errors)
       end
-    rescue
-      e -> {:error, %{validation_error: Exception.message(e)}}
+    end)
+  end
+
+  # Validate individual field type
+  defp validate_field_type(field, field_schema, value, errors) do
+    expected_type = Map.get(field_schema, "type")
+    actual_type = determine_json_type(value)
+
+    if expected_type != actual_type do
+      Map.put(errors, field, "expected #{expected_type}, got #{actual_type}")
+    else
+      errors
     end
   end
 

lib/llm_agent/providers/openai.ex

@@ -531,26 +531,24 @@ defmodule LLMAgent.Providers.OpenAI do
 
   # Retry mechanism for API calls
   defp call_with_retry(api_call, max_retries, current_retry \\ 0, backoff_ms \\ 1000) do
-    try do
-      api_call.()
-    rescue
-      e ->
-        if current_retry < max_retries do
-          # Exponential backoff with jitter
-          jitter = :rand.uniform(div(backoff_ms, 4))
-          wait_time = backoff_ms + jitter
-
-          Logger.warning(
-            "API call failed, retrying (#{current_retry + 1}/#{max_retries}) after #{wait_time}ms: #{Exception.message(e)}"
-          )
-
-          :timer.sleep(wait_time)
-          call_with_retry(api_call, max_retries, current_retry + 1, backoff_ms * 2)
-        else
-          Logger.error("API call failed after #{max_retries} retries: #{Exception.message(e)}")
-          {:error, %{message: Exception.message(e), exception: e}}
-        end
-    end
+    api_call.()
+  rescue
+    e ->
+      if current_retry < max_retries do
+        # Exponential backoff with jitter
+        jitter = :rand.uniform(div(backoff_ms, 4))
+        wait_time = backoff_ms + jitter
+
+        Logger.warning(
+          "API call failed, retrying (#{current_retry + 1}/#{max_retries}) after #{wait_time}ms: #{Exception.message(e)}"
+        )
+
+        :timer.sleep(wait_time)
+        call_with_retry(api_call, max_retries, current_retry + 1, backoff_ms * 2)
+      else
+        Logger.error("API call failed after #{max_retries} retries: #{Exception.message(e)}")
+        {:error, %{message: Exception.message(e), exception: e}}
+      end
   end
 
   # Mock responses for testing and development

lib/llm_agent/tasks.ex

@@ -354,22 +354,20 @@ defmodule LLMAgent.Tasks do
 
   defp execute_task_with_stages(task_flow, signal, task_state, timeout_ms) do
     # Similar to collect_stage_results but simpler for synchronous execution
-    try do
-      {results, states} = collect_stage_results(task_flow, signal, task_state, timeout_ms)
-      final_result = List.last(results)
-      final_state = List.last(states)
+    {results, states} = collect_stage_results(task_flow, signal, task_state, timeout_ms)
+    final_result = List.last(results)
+    final_state = List.last(states)
 
-      case final_result[:status] do
-        "completed" ->
-          {:ok, final_result[:result], results, final_state}
+    case final_result[:status] do
+      "completed" ->
+        {:ok, final_result[:result], results, final_state}
 
-        "error" ->
-          {:error, final_result[:error], final_result[:name], final_state}
-      end
-    catch
-      kind, error ->
-        error_msg = Exception.format(kind, error, __STACKTRACE__)
-        {:error, error_msg, task_state.task_stage, task_state}
+      "error" ->
+        {:error, final_result[:error], final_result[:name], final_state}
     end
+  catch
+    kind, error ->
+      error_msg = Exception.format(kind, error, __STACKTRACE__)
+      {:error, error_msg, task_state.task_stage, task_state}
   end
 end