fix: CSM-001 done

lib/bds/ai/catalog.ex

@@ -15,6 +15,7 @@ defmodule BDS.AI.Catalog do
   alias BDS.AI.Model
   alias BDS.AI.ModelModality
   alias BDS.AI.OpenAICompatibleRuntime
+  alias BDS.MapUtils
   alias BDS.Persistence
   alias BDS.Repo
 
@@ -211,9 +212,7 @@ defmodule BDS.AI.Catalog do
     end
   end
 
-  defp atomize_map_keys(map) do
-    Enum.into(map, %{}, fn {key, value} -> {String.to_atom(key), value} end)
-  end
+  defp atomize_map_keys(map), do: MapUtils.safe_atomize_keys(map)
 
   defp persist_catalog(payload) do
     now = Persistence.now_ms()
@@ -313,7 +312,7 @@ defmodule BDS.AI.Catalog do
   defp parse_modality("audio"), do: :audio
   defp parse_modality("file"), do: :file
   defp parse_modality("tool"), do: :tool
-  defp parse_modality(other) when is_binary(other), do: String.to_atom(other)
+  defp parse_modality(other) when is_binary(other), do: MapUtils.safe_atomize_key(other)
 
   defp encode_nullable(nil), do: nil
   defp encode_nullable(value), do: Jason.encode!(value)

lib/bds/ai/chat_tools.ex

@@ -909,7 +909,7 @@ defmodule BDS.AI.ChatTools do
 
   defp metadata_attrs(arguments, keys) do
     Enum.reduce(keys, %{}, fn key, acc ->
-      maybe_put(acc, String.to_atom(key), arguments[key])
+      maybe_put(acc, BDS.MapUtils.safe_atomize_key(key), arguments[key])
     end)
   end
 

lib/bds/desktop/automation.ex

@@ -375,13 +375,7 @@ defmodule BDS.Desktop.Automation do
   defp normalize_simple_reply("ok"), do: :ok
   defp normalize_simple_reply(reply), do: reply
 
-  defp atomize_map(map) when is_map(map) do
-    Enum.into(map, %{}, fn {key, value} ->
-      normalized_key = if is_binary(key), do: String.to_atom(key), else: key
-      normalized_value = if is_map(value), do: atomize_map(value), else: value
-      {normalized_key, normalized_value}
-    end)
-  end
+  defp atomize_map(map) when is_map(map), do: BDS.MapUtils.safe_atomize_keys(map)
 
   defp project_root do
     Path.expand("../../..", __DIR__)

lib/bds/desktop/shell_live/chat_editor/tool_surfaces.ex

@@ -287,7 +287,7 @@ defmodule BDS.Desktop.ShellLive.ChatEditor.ToolSurfaces do
   defp map_value(map, key, default \\ nil)
 
   defp map_value(map, key, default) when is_map(map) and is_binary(key) do
-    Map.get(map, key, Map.get(map, String.to_atom(key), default))
+    Map.get(map, key, Map.get(map, String.to_existing_atom(key), default))
   rescue
     ArgumentError -> Map.get(map, key, default)
   end

lib/bds/import_definitions.ex

@@ -91,19 +91,11 @@ defmodule BDS.ImportDefinitions do
   defp maybe_put(map, _key, nil), do: map
   defp maybe_put(map, key, value), do: Map.put(map, key, value)
 
+  alias BDS.MapUtils
+
   defp normalize_analysis_result(nil), do: nil
   defp normalize_analysis_result(value) when is_binary(value), do: value
   defp normalize_analysis_result(value), do: Jason.encode!(value)
 
-  defp atomize_keys(value) when is_map(value) do
-    value
-    |> Enum.map(fn {key, nested_value} ->
-      normalized_key = if(is_binary(key), do: String.to_atom(key), else: key)
-      {normalized_key, atomize_keys(nested_value)}
-    end)
-    |> Map.new()
-  end
-
-  defp atomize_keys(value) when is_list(value), do: Enum.map(value, &atomize_keys/1)
-  defp atomize_keys(value), do: value
+  defp atomize_keys(value), do: MapUtils.safe_atomize_keys(value)
 end

lib/bds/import_execution.ex

@@ -6,6 +6,7 @@ defmodule BDS.ImportExecution do
   alias BDS.Posts
   alias BDS.Posts.Post
   alias BDS.Repo
+  alias BDS.MapUtils
   alias BDS.Tags
 
   def execute_import(project_id, report, opts \\ [])
@@ -535,17 +536,7 @@ defmodule BDS.ImportExecution do
   defp item_identity(%{item_type: "media", filename: filename}), do: {:media, filename}
   defp item_identity(%{item_type: item_type, slug: slug}), do: {item_type, slug}
 
-  defp normalize_report(report) when is_map(report) do
-    report
-    |> Enum.map(fn {key, value} ->
-      normalized_key = if(is_binary(key), do: String.to_atom(key), else: key)
-      {normalized_key, normalize_report(value)}
-    end)
-    |> Map.new()
-  end
-
-  defp normalize_report(report) when is_list(report), do: Enum.map(report, &normalize_report/1)
-  defp normalize_report(report), do: report
+  defp normalize_report(report), do: MapUtils.safe_atomize_keys(report)
 
   defp normalize_item(item) do
     normalize_report(item)

lib/bds/map_utils.ex

@@ -30,4 +30,25 @@ defmodule BDS.MapUtils do
   def blank_to_nil(nil), do: nil
   def blank_to_nil(""), do: nil
   def blank_to_nil(value), do: value
+
+  @spec safe_atomize_key(atom() | String.t()) :: atom() | String.t()
+  def safe_atomize_key(key) when is_atom(key), do: key
+
+  def safe_atomize_key(key) when is_binary(key) do
+    String.to_existing_atom(key)
+  rescue
+    ArgumentError -> key
+  end
+
+  @spec safe_atomize_keys(term()) :: term()
+  def safe_atomize_keys(value) when is_map(value) do
+    value
+    |> Enum.map(fn {key, nested_value} ->
+      {safe_atomize_key(key), safe_atomize_keys(nested_value)}
+    end)
+    |> Map.new()
+  end
+
+  def safe_atomize_keys(value) when is_list(value), do: Enum.map(value, &safe_atomize_keys/1)
+  def safe_atomize_keys(value), do: value
 end

lib/bds/release_packaging.ex

@@ -69,7 +69,7 @@ defmodule BDS.ReleasePackaging do
   defp normalize_platform(:darwin), do: :macos
 
   defp normalize_platform(platform) when is_binary(platform),
-    do: platform |> String.downcase() |> String.to_atom()
+    do: platform |> String.downcase() |> String.to_existing_atom()
 
   defp archive_extension(:windows), do: ".zip"
   defp archive_extension(_platform), do: ".tar.gz"

lib/bds/ui/menu_bar.ex

@@ -121,7 +121,7 @@ defmodule BDS.UI.MenuBar do
 
   defp sidebar_view_command(command_id) do
     with "view_" <> suffix <- Atom.to_string(command_id),
-         view_id = String.to_atom(suffix),
+         view_id = String.to_existing_atom(suffix),
          %{} <- Registry.sidebar_view(view_id) do
       {:ok, view_id}
     else
@@ -131,7 +131,7 @@ defmodule BDS.UI.MenuBar do
 
   defp singleton_editor_command(command_id) do
     with "open_" <> suffix <- Atom.to_string(command_id),
-         route_id = String.to_atom(suffix),
+         route_id = String.to_existing_atom(suffix),
          %{singleton: true} <- Registry.editor_route(route_id) do
       {:ok, route_id}
     else

lib/bds/ui/workbench.ex

@@ -267,7 +267,7 @@ defmodule BDS.UI.Workbench do
   defp token_usage(_state, _usage), do: nil
 
   defp normalize_type(type) when is_atom(type), do: type
-  defp normalize_type(type) when is_binary(type), do: String.to_atom(type)
+  defp normalize_type(type) when is_binary(type), do: String.to_existing_atom(type)
 
   defp tab_ref(tab), do: {tab.type, tab.id}