add some bedrock test

Author: michaeljguarino

config/config.exs

@@ -87,16 +87,16 @@ config :console, :ai_defaults,
   },
   vertex: %{
     model: "claude-haiku-4-5@20251001",
-    tool_model: "claude-sonnet-4-5@20250929",
+    tool_model: "claude-sonnet-4-6@20260114",
     embedding_model: "gemini-embedding-001"
   },
   anthropic: %{
     model: "claude-4-5-haiku-latest",
-    tool_model: "claude-4-5-sonnet-latest"
+    tool_model: "claude-4-6-sonnet-latest"
   },
   bedrock: %{
     model: "us.anthropic.claude-haiku-4-5-20251001-v1:0",
-    tool_model: "us.anthropic.claude-sonnet-4-5-20250929-v1:0",
+    tool_model: "us.anthropic.claude-sonnet-4-6",
     embedding_model: "cohere.embed-english-v3"
   },
   ollama: %{},

lib/console/ai/provider/base.ex

@@ -89,7 +89,7 @@ defmodule Console.AI.Provider.Base do
   def tool_calls({:ok, binary}), do: {:error, "no tool calls in response, got: #{binary}"}
   def tool_calls(err), do: err
 
-  defp model(name) when is_binary(name), do: LLMDB.model(name)
+  defp model(name) when is_binary(name), do: ReqLLM.model(name)
   defp model(%LLMDB.Model{} = model), do: {:ok, model}
   defp model(model), do: {:error, "invalid model: #{inspect(model)}"}
 

lib/console/deployments/stacks.ex

@@ -911,10 +911,15 @@ defmodule Console.Deployments.Stacks do
     |> Repo.exists?()
   end
 
-  defp filter(%Stack{id: id}), do: StackRun.for_stack(id)
+  defp filter(%Stack{id: id}) do
+    StackRun.for_stack(id)
+    |> StackRun.wet()
+  end
+
   defp filter(%PullRequest{stack_id: sid, id: id}) do
     StackRun.for_stack(sid)
     |> StackRun.for_pr(id)
+    |> StackRun.dry()
   end
 
   @doc """

priv/prompts/workbench/coding_output.md.eex

@@ -6,7 +6,7 @@ The coding agent completed its task.  Here are the results:
 ## Summary
 <%= @analysis.summary %>
 
-<%= Enum.map(@analysis.bullets, &"- #{&1}") |> Enum.join("\n") %>
+<%= Enum.map(@analysis.bullets || [], &"- #{&1}") |> Enum.join("\n") %>
 
 ## Details
 <%= @analysis.analysis %>

test/console/ai/provider/bedrock_test.exs

@@ -0,0 +1,102 @@
+defmodule Console.AI.Provider.BedrockTest do
+  use ExUnit.Case, async: false
+  use Mimic
+
+  alias Console.AI.{Bedrock, Tool}
+  alias Console.Schema.DeploymentSettings.AI.Bedrock, as: BedrockSettings
+  alias ReqLLM.{Message, Message.ContentPart, Response, ToolCall}
+
+  @inference_profile_id "us.anthropic.claude-sonnet-4-6"
+  @region "us-east-2"
+  @usage %{input_tokens: 10, output_tokens: 5, total_tokens: 15}
+
+  setup :set_mimic_global
+
+  describe "tool_call/4" do
+    test "calls the configured inference profile id in the Bedrock runtime REST URL" do
+      bedrock =
+        Bedrock.new(%BedrockSettings{
+          tool_model_id: @inference_profile_id,
+          region: @region,
+          aws_access_key_id: "test-access-key",
+          aws_secret_access_key: "test-secret-key"
+        })
+
+      expected_url =
+        "https://bedrock-runtime.#{@region}.amazonaws.com/model/#{@inference_profile_id}/converse"
+
+      expect(Req, :request, fn %Req.Request{} = request ->
+        assert request.method == :post
+        assert URI.to_string(request.url) == expected_url
+
+        {:ok,
+         %Req.Response{
+           status: 200,
+           body: %Response{
+             id: "test-response",
+             model: @inference_profile_id,
+             context: %ReqLLM.Context{messages: []},
+             message: %Message{
+               role: :assistant,
+               content: [],
+               tool_calls: [
+                 ToolCall.new("call-1", "enable_tools", ~s({"tools":["search"]}))
+               ]
+             },
+             finish_reason: :tool_use,
+             usage: @usage,
+             stream?: false
+           }
+         }}
+      end)
+
+      assert {:ok, [%Tool{name: "enable_tools"} | _]} =
+               Bedrock.tool_call(
+                 bedrock,
+                 [{:user, "enable search"}],
+                 [%Console.AI.Tools.EnableTools{}],
+                 []
+               )
+    end
+  end
+
+  describe "completion/3" do
+    test "calls the configured inference profile id in the Bedrock runtime REST URL" do
+      bedrock =
+        Bedrock.new(%BedrockSettings{
+          model_id: @inference_profile_id,
+          region: @region,
+          aws_access_key_id: "test-access-key",
+          aws_secret_access_key: "test-secret-key"
+        })
+
+      expected_url =
+        "https://bedrock-runtime.#{@region}.amazonaws.com/model/#{@inference_profile_id}/invoke"
+
+      expect(Req, :request, fn %Req.Request{} = request ->
+        assert request.method == :post
+        assert URI.to_string(request.url) == expected_url
+
+        {:ok,
+         %Req.Response{
+           status: 200,
+           body: %Response{
+             id: "test-response",
+             model: @inference_profile_id,
+             context: %ReqLLM.Context{messages: []},
+             message: %Message{
+               role: :assistant,
+               content: [%ContentPart{type: :text, text: "hello"}]
+             },
+             finish_reason: :stop,
+             usage: @usage,
+             stream?: false
+           }
+         }}
+      end)
+
+      assert {:ok, "hello"} =
+               Bedrock.completion(bedrock, [{:user, "hi"}], [])
+    end
+  end
+end

test/console/deployments/stacks_test.exs

@@ -873,14 +873,40 @@ defmodule Console.Deployments.StacksTest do
       {:error, _} = Stacks.dequeue(stack)
     end
 
-    test "it will fail if the stack is currently running a pr run" do
+    test "it will dequeue wet runs while a pr dry run is running" do
+      stack = insert(:stack)
+      pr = insert(:pull_request, stack: stack)
+      insert(:stack_run, stack: stack, status: :pending, pull_request: pr, dry_run: true)
+      :timer.sleep(1)
+      run = insert(:stack_run, stack: stack, status: :queued)
+
+      {:ok, dequeued} = Stacks.dequeue(stack)
+
+      assert dequeued.id == run.id
+      assert dequeued.status == :pending
+    end
+
+    test "it will fail if the pr is currently running a dry run" do
       stack = insert(:stack)
       pr = insert(:pull_request, stack: stack)
       insert(:stack_run, stack: stack, status: :pending, pull_request: pr, dry_run: true)
       :timer.sleep(1)
       insert(:stack_run, stack: stack, status: :queued, pull_request: pr, dry_run: true)
 
-      {:error, _} = Stacks.dequeue(stack)
+      {:error, _} = Stacks.dequeue(pr)
+    end
+
+    test "it will dequeue dry pr runs while a wet run is running" do
+      stack = insert(:stack)
+      pr = insert(:pull_request, stack: stack)
+      insert(:stack_run, stack: stack, status: :pending)
+      :timer.sleep(1)
+      run = insert(:stack_run, stack: stack, status: :queued, pull_request: pr, dry_run: true)
+
+      {:ok, dequeued} = Stacks.dequeue(pr)
+
+      assert dequeued.id == run.id
+      assert dequeued.status == :pending
     end
 
     test "it will fail if there are no runs to dequeue" do