+ <%= case @surface.type do %>
+ <% "card" -> %>
+
+ <%= if present?(@surface.title) do %>
+
<%= @surface.title %>
+ <% end %>
+ <%= if present?(@surface.subtitle) do %>
+
<%= @surface.subtitle %>
+ <% end %>
+
<%= @surface.body %>
+ <%= if @surface.actions != [] do %>
+
+ <%= for action <- @surface.actions do %>
+
+ <%= action.label %>
+
+ <% end %>
+
+ <% end %>
+
<%= @surface.title %>
+ <% end %>
+
+
+ <% "chart" -> %>
+ <%= if present?(@surface.title) do %>
+ <%= @surface.title %>
+ <% end %>
+ <%= @surface.chart_type %>
+
+ <%= for series <- @surface.series do %>
+
+
+ <%= series.label %>
+ <%= series.value %>
+
+
+
+
+ <% end %>
+
+ <%= @surface.label %>
+ <%= @surface.value %>
+
+
+ <% "list" -> %>
+ <%= if present?(@surface.title) do %>
+ <%= @surface.title %>
+ <% end %>
+
+ <%= for item <- @surface.items do %>
+ <%= item %>
+ <% end %>
+
+
+ <% "mindmap" -> %>
+ <%= if present?(@surface.title) do %>
+ <%= @surface.title %>
+ <% end %>
+
+ <%= for node <- @surface.nodes do %>
+
+ <%= node.label %>
+ <%= if node.children != [] do %>
+ <%= Enum.join(node.children, ", ") %>
+ <% end %>
+
+ <% end %>
+
+
+ <% "tabs" -> %>
+ <%= if present?(@surface.title) do %>
+ <%= @surface.title %>
+ <% end %>
+
+
+ <%= for {tab, index} <- Enum.with_index(@surface.tabs) do %>
+
+ <%= tab.label %>
+
+ <% end %>
+
+
+ <%= case Enum.at(@surface.tabs, @surface.selected_index || 0) do %>
+ <% nil -> %>
+ <% tab -> %>
+
+ <%= for content <- tab.content do %>
+ <.chat_surface surface={content} />
+ <% end %>
+
+ <% end %>
+
<%= @surface.title %>
+ <% end %>
+
+
+ <%= if present?(@surface.submit_label) do %>
+
+
+ <%= @surface.submit_label %>
+
+
+ <% end %>
+
+ <% "text" -> %>
+ <%= @surface.body %>
+
+ <% _other -> %>
+ <%= Jason.encode!(@surface.raw || %{}, pretty: true) %>
+ <% end %>
+
+ """
+ end
+
+ defp build_entries(messages, assigns) do
+ {entries, current_entry, _turn_index} =
+ Enum.reduce(messages, {[], nil, -1}, fn message, {entries, current_entry, turn_index} ->
case message.role do
:tool ->
if current_entry && current_entry.role == :assistant do
- {entries, append_tool_surface(current_entry, message)}
+ {entries, append_tool_surface(current_entry, message), turn_index}
else
- {entries, current_entry}
+ {entries, current_entry, turn_index}
end
:system ->
- {entries, current_entry}
+ {entries, current_entry, turn_index}
+
+ :user ->
+ entries = finalize_entry(entries, current_entry)
+ next_turn_index = turn_index + 1
+ {entries, start_entry(message, next_turn_index, assigns), next_turn_index}
_other ->
entries = finalize_entry(entries, current_entry)
- {entries, start_entry(message)}
+ {entries, start_entry(message, turn_index, assigns), turn_index}
end
end)
@@ -128,17 +524,23 @@ defmodule BDS.Desktop.ShellLive.ChatEditor do
defp finalize_entry(entries, nil), do: entries
defp finalize_entry(entries, entry), do: [entry | entries]
- defp start_entry(message) do
+ defp start_entry(message, turn_index, assigns) do
+ tool_markers = normalize_tool_calls(message.tool_calls)
+
%{
id: message.id,
role: message.role,
content: message.content || "",
- tool_markers: normalize_tool_calls(message.tool_calls),
+ turn_index: turn_index,
+ tool_markers: tool_markers,
+ inline_surfaces: build_render_surfaces(tool_markers, message.id, assigns),
tool_surfaces: []
}
end
defp append_tool_surface(entry, message) do
+ entry = mark_tool_call_completed(entry, message.tool_call_id)
+
case normalize_tool_surface(message.content) do
nil -> entry
surface -> update_in(entry.tool_surfaces, &(&1 ++ [surface]))
@@ -147,15 +549,254 @@ defmodule BDS.Desktop.ShellLive.ChatEditor do
defp normalize_tool_calls(tool_calls) when is_list(tool_calls) do
Enum.map(tool_calls, fn tool_call ->
+ arguments = tool_call_arguments(tool_call)
+
%{
+ id: Map.get(tool_call, "id") || Map.get(tool_call, :id),
name: tool_call_name(tool_call),
- arguments: Map.get(tool_call, "arguments") || Map.get(tool_call, :arguments) || Map.get(tool_call, "args") || Map.get(tool_call, :args) || %{}
+ arguments: arguments,
+ args_preview: tool_arguments_preview(arguments),
+ complete?: false
}
end)
end
defp normalize_tool_calls(_tool_calls), do: []
+ defp build_render_surfaces(tool_calls, message_id, assigns) do
+ tool_calls
+ |> Enum.with_index()
+ |> Enum.flat_map(fn {tool_call, index} ->
+ case build_render_surface(tool_call, "#{message_id}-surface-#{index}", assigns) do
+ nil -> []
+ surface -> [surface]
+ end
+ end)
+ end
+
+ defp build_render_surface(%{name: name, arguments: arguments}, surface_id, assigns) do
+ if MapSet.member?(@render_tool_names, name) do
+ do_build_render_surface(name, arguments || %{}, surface_id, assigns)
+ end
+ end
+
+ defp do_build_render_surface("render_card", arguments, surface_id, _assigns) do
+ %{
+ id: surface_id,
+ type: "card",
+ title: map_value(arguments, "title"),
+ subtitle: map_value(arguments, "subtitle"),
+ body: map_value(arguments, "body", ""),
+ actions: decode_surface_actions(map_value(arguments, "actions", []))
+ }
+ end
+
+ defp do_build_render_surface("render_table", arguments, surface_id, _assigns) do
+ %{
+ id: surface_id,
+ type: "table",
+ title: map_value(arguments, "title"),
+ columns: stringify_list(map_value(arguments, "columns", [])),
+ rows: Enum.map(List.wrap(map_value(arguments, "rows", [])), &stringify_list/1)
+ }
+ end
+
+ defp do_build_render_surface("render_chart", arguments, surface_id, _assigns) do
+ series =
+ map_value(arguments, "series", [])
+ |> List.wrap()
+ |> Enum.map(fn entry ->
+ %{
+ label: map_value(entry, "label", translated("chat.role.assistant")),
+ value: numeric_value(map_value(entry, "value", 0)),
+ segments: List.wrap(map_value(entry, "segments", []))
+ }
+ end)
+
+ %{
+ id: surface_id,
+ type: "chart",
+ title: map_value(arguments, "title"),
+ chart_type: map_value(arguments, "chart_type", "bar"),
+ series: series,
+ max_value: Enum.max([0 | Enum.map(series, & &1.value)])
+ }
+ end
+
+ defp do_build_render_surface("render_metric", arguments, surface_id, _assigns) do
+ %{
+ id: surface_id,
+ type: "metric",
+ label: map_value(arguments, "label", "Metric"),
+ value: map_value(arguments, "value", "")
+ }
+ end
+
+ defp do_build_render_surface("render_list", arguments, surface_id, _assigns) do
+ %{
+ id: surface_id,
+ type: "list",
+ title: map_value(arguments, "title"),
+ items: stringify_list(map_value(arguments, "items", []))
+ }
+ end
+
+ defp do_build_render_surface("render_mindmap", arguments, surface_id, _assigns) do
+ nodes =
+ arguments
+ |> map_value("nodes", [])
+ |> List.wrap()
+ |> Enum.map(fn node ->
+ %{
+ id: map_value(node, "id"),
+ label: map_value(node, "label", "Node"),
+ children: stringify_list(map_value(node, "children", []))
+ }
+ end)
+
+ %{
+ id: surface_id,
+ type: "mindmap",
+ title: map_value(arguments, "title"),
+ nodes: nodes
+ }
+ end
+
+ defp do_build_render_surface("render_form", arguments, surface_id, assigns) do
+ stored_fields = Map.get(assigns.chat_editor_surface_data, surface_id, %{})
+
+ fields =
+ arguments
+ |> map_value("fields", [])
+ |> List.wrap()
+ |> Enum.map(fn field ->
+ key = map_value(field, "key", "field")
+
+ %{
+ key: key,
+ label: map_value(field, "label", key),
+ input_type: map_value(field, "inputType") || map_value(field, "input_type", "text"),
+ placeholder: map_value(field, "placeholder"),
+ value: Map.get(stored_fields, key, map_value(field, "defaultValue") || map_value(field, "default_value")),
+ options: decode_surface_options(map_value(field, "options", [])),
+ required?: truthy?(map_value(field, "required", false))
+ }
+ end)
+
+ %{
+ id: surface_id,
+ type: "form",
+ title: map_value(arguments, "title"),
+ fields: fields,
+ submit_label: map_value(arguments, "submitLabel") || map_value(arguments, "submit_label", translated("chat.stop")),
+ submit_action: map_value(arguments, "submitAction") || map_value(arguments, "submit_action", "submitForm")
+ }
+ end
+
+ defp do_build_render_surface("render_tabs", arguments, surface_id, assigns) do
+ tabs =
+ arguments
+ |> map_value("tabs", [])
+ |> List.wrap()
+ |> Enum.with_index()
+ |> Enum.map(fn {tab, tab_index} ->
+ %{
+ label: map_value(tab, "label", "Tab #{tab_index + 1}"),
+ content:
+ tab
+ |> map_value("content", [])
+ |> List.wrap()
+ |> Enum.with_index()
+ |> Enum.map(fn {content, content_index} ->
+ build_tab_surface(content, "#{surface_id}-tab-#{tab_index}-#{content_index}", assigns)
+ end)
+ }
+ end)
+
+ %{
+ id: surface_id,
+ type: "tabs",
+ title: map_value(arguments, "title"),
+ tabs: tabs,
+ selected_index: Map.get(assigns.chat_editor_surface_tabs, surface_id, 0)
+ }
+ end
+
+ defp do_build_render_surface(_name, arguments, surface_id, _assigns) do
+ %{id: surface_id, type: "json", raw: arguments}
+ end
+
+ defp build_tab_surface(%{} = content, surface_id, assigns) do
+ type = map_value(content, "type", "text")
+
+ case type do
+ render_type when render_type in ["card", "chart", "form", "list", "metric", "mindmap", "table", "tabs"] ->
+ do_build_render_surface("render_#{render_type}", Map.delete(content, "type"), surface_id, assigns)
+
+ "text" ->
+ %{id: surface_id, type: "text", body: map_value(content, "body") || map_value(content, "text", "")}
+
+ _other ->
+ %{id: surface_id, type: "json", raw: content}
+ end
+ end
+
+ defp build_tab_surface(content, surface_id, _assigns) do
+ %{id: surface_id, type: "text", body: to_string(content || "")}
+ end
+
+ defp mark_tool_call_completed(entry, tool_call_id) when is_binary(tool_call_id) do
+ update_in(entry.tool_markers, fn markers ->
+ Enum.map(markers, fn marker ->
+ if marker.id == tool_call_id do
+ %{marker | complete?: true}
+ else
+ marker
+ end
+ end)
+ end)
+ end
+
+ defp mark_tool_call_completed(entry, _tool_call_id), do: entry
+
+ defp decode_surface_actions(actions) when is_list(actions) do
+ Enum.map(actions, fn action ->
+ %{
+ label: map_value(action, "label", translated("chat.openSettings")),
+ action: map_value(action, "action", "openSettings"),
+ payload: map_value(action, "payload", %{})
+ }
+ end)
+ end
+
+ defp decode_surface_actions(_actions), do: []
+
+ defp decode_surface_options(options) when is_list(options) do
+ Enum.map(options, fn option ->
+ %{
+ label: map_value(option, "label", ""),
+ value: map_value(option, "value", "")
+ }
+ end)
+ end
+
+ defp decode_surface_options(_options), do: []
+
+ defp tool_arguments_preview(arguments) when is_map(arguments) do
+ arguments
+ |> Enum.map(fn {key, value} -> "#{key}: #{preview_value(value)}" end)
+ |> Enum.join(", ")
+ end
+
+ defp tool_arguments_preview(_arguments), do: ""
+
+ defp preview_value(value) when is_binary(value) do
+ quoted = if String.length(value) > @tool_args_max_length, do: String.slice(value, 0, @tool_args_max_length) <> "...", else: value
+ inspect(quoted)
+ end
+
+ defp preview_value(value), do: inspect(value)
+
defp normalize_tool_surface(content) when is_binary(content) do
case Jason.decode(content) do
{:ok, %{"type" => type} = decoded} ->
@@ -175,5 +816,138 @@ defmodule BDS.Desktop.ShellLive.ChatEditor do
defp normalize_tool_surface(_content), do: nil
+ defp pending_user_message(_messages, nil), do: nil
+
+ defp pending_user_message(messages, %{message: message}) when is_binary(message) do
+ case messages |> Enum.reverse() |> Enum.find(&(&1.role not in [:system, :tool])) do
+ %{role: :user, content: ^message} -> nil
+ _other -> message
+ end
+ end
+
+ defp pending_user_message(_messages, _request), do: nil
+
+ defp streaming_content(nil), do: ""
+ defp streaming_content(%{content: content}) when is_binary(content), do: content
+ defp streaming_content(_request), do: ""
+
+ defp tool_markers_from_events(nil), do: []
+
+ defp tool_markers_from_events(%{tool_events: tool_events}) do
+ Enum.reduce(tool_events || [], [], fn event, markers ->
+ case event.type do
+ :call -> markers ++ [%{id: nil, name: event.name, arguments: event.arguments, args_preview: tool_arguments_preview(event.arguments || %{}), complete?: false}]
+
+ :result ->
+ Enum.reverse(markers)
+ |> mark_last_matching_complete(event.name)
+ |> Enum.reverse()
+ end
+ end)
+ end
+
+ defp mark_last_matching_complete(markers, name) do
+ {updated, found?} =
+ Enum.map_reduce(markers, false, fn marker, found? ->
+ cond do
+ found? -> {marker, true}
+ marker.name == name and not marker.complete? -> {%{marker | complete?: true}, true}
+ true -> {marker, false}
+ end
+ end)
+
+ if found?, do: updated, else: updated
+ end
+
+ defp update_request(socket, conversation_id, updater, reload) do
+ case Map.get(socket.assigns.chat_editor_requests, conversation_id) do
+ nil -> socket
+
+ request ->
+ socket
+ |> assign(:chat_editor_requests, Map.put(socket.assigns.chat_editor_requests, conversation_id, updater.(request)))
+ |> reload.(socket.assigns.workbench)
+ end
+ end
+
+ defp allow_repo_sandbox(pid) when is_pid(pid) do
+ if Code.ensure_loaded?(Ecto.Adapters.SQL.Sandbox) do
+ try do
+ Ecto.Adapters.SQL.Sandbox.allow(BDS.Repo, self(), pid)
+ rescue
+ _error -> :ok
+ end
+ else
+ :ok
+ end
+
+ :ok
+ end
+
+ defp needs_api_key?(true), do: false
+
+ defp needs_api_key?(false) do
+ case AI.get_endpoint(:online) do
+ {:ok, %{url: url, model: model, api_key: api_key}} -> blank?(url) or blank?(model) or blank?(api_key)
+ _other -> true
+ end
+ end
+
+ defp blank?(value) when is_binary(value), do: String.trim(value) == ""
+ defp blank?(nil), do: true
+ defp blank?(_value), do: false
+
+ defp rewrite_external_images(html) do
+ html =
+ Regex.replace(~r/