fix: accept indexed web search tool shape

masterkain · masterkain · commit 0f3f74343de1 · 2026-06-25T09:33:16.000+02:00
diff --git a/lib/codex_pooler/gateway/openai_compatibility/responses.ex b/lib/codex_pooler/gateway/openai_compatibility/responses.ex
@@ -451,6 +451,10 @@ defmodule CodexPooler.Gateway.OpenAICompatibility.Responses do
     end
   end
 
+  defp validate_index_gated_web_access(%{"index_gated_web_access" => false}) do
+    {:error, Error.invalid_request("tool shape is not translatable", "tools")}
+  end
+
   defp validate_index_gated_web_access(%{
          "external_web_access" => false,
          "index_gated_web_access" => true
diff --git a/test/codex_pooler/gateway/openai_compatibility/core_test.exs b/test/codex_pooler/gateway/openai_compatibility/core_test.exs
@@ -2265,14 +2265,18 @@ defmodule CodexPooler.Gateway.OpenAICompatibilityTest do
     test "Responses allows only exact safe passthrough built-in tool shapes" do
       for tool <- [
             %{"type" => "web_search_preview"},
+            %{
+              "type" => "web_search",
+              "external_web_access" => false
+            },
             %{
               "type" => "web_search",
               "external_web_access" => true,
               "index_gated_web_access" => true
             },
             %{
               "type" => "web_search",
-              "external_web_access" => false
+              "external_web_access" => true
             },
             %{"type" => "image_generation"},
             %{
@@ -2305,6 +2309,11 @@ defmodule CodexPooler.Gateway.OpenAICompatibilityTest do
           "external_web_access" => true,
           "index_gated_web_access" => "true"
         },
+        %{
+          "type" => "web_search",
+          "external_web_access" => true,
+          "index_gated_web_access" => false
+        },
         %{
           "type" => "web_search",
           "external_web_access" => false,
diff --git a/test/codex_pooler/gateway/request_compression/maybe_compress_test.exs b/test/codex_pooler/gateway/request_compression/maybe_compress_test.exs
@@ -68,6 +68,51 @@ defmodule CodexPooler.Gateway.RequestCompression.MaybeCompressTest do
       refute inspect(metadata) =~ "call_direct_compression"
     end
 
+    test "preserves indexed web search tools while rewriting eligible outputs" do
+      tool = %{
+        "type" => "web_search",
+        "external_web_access" => true,
+        "index_gated_web_access" => true
+      }
+
+      original_output = compression_log_fixture("indexed tool compression sentinel")
+
+      body =
+        Jason.encode!(%{
+          "model" => @supported_model,
+          "tools" => [tool],
+          "input" => [
+            %{
+              "type" => "local_shell_call_output",
+              "call_id" => "call_indexed_tool_compression",
+              "output" => original_output
+            }
+          ]
+        })
+
+      {context, request_options} = request_context(body)
+
+      assert {compressed_body, compressed_options} =
+               RequestCompression.maybe_compress(body, context, request_options)
+
+      assert compressed_body != body
+      assert Jason.decode!(compressed_body)["tools"] == [tool]
+
+      compressed_output = first_output(compressed_body)
+      assert compressed_output =~ "[compressed log output: omitted"
+      refute compressed_output =~ "indexed tool compression sentinel"
+
+      assert %{
+               "status" => "compressed",
+               "candidate_count" => 1,
+               "compressed_count" => 1,
+               "skipped_count" => 0
+             } = metadata = compressed_options.runtime.payload_compression
+
+      refute inspect(metadata) =~ "indexed tool compression sentinel"
+      refute inspect(metadata) =~ "call_indexed_tool_compression"
+    end
+
     test "preserves original output when failure summaries prove compression incomplete" do
       omitted_sentinel = "incomplete failure detail omitted sentinel"
       original_output = incomplete_failure_log_fixture(omitted_sentinel)
diff --git a/test/codex_pooler/gateway/request_compression/performance_test.exs b/test/codex_pooler/gateway/request_compression/performance_test.exs
@@ -4,6 +4,7 @@ defmodule CodexPooler.Gateway.RequestCompression.PerformanceTest do
   alias CodexPooler.Catalog.Model
   alias CodexPooler.Gateway.Payloads.RequestOptions
   alias CodexPooler.Gateway.RequestCompression
+  alias CodexPooler.Gateway.RequestCompression.TokenCounter
   alias CodexPooler.Gateway.Runtime.Dispatch.Context
   alias CodexPooler.Gateway.Runtime.Dispatch.RouteState
   alias CodexPooler.Pools.RoutingSettings
@@ -18,6 +19,11 @@ defmodule CodexPooler.Gateway.RequestCompression.PerformanceTest do
   @local_budget_ms 500
   @supported_model "gpt-4o"
 
+  setup_all do
+    assert {:ok, _count, _metadata} = TokenCounter.count(@supported_model, "warm tokenizer ranks")
+    :ok
+  end
+
   describe "request compression guardrails" do
     test "skips over-limit bodies before JSON scanning" do
       body = "{" <> String.duplicate("x", @max_body_bytes)
@@ -199,6 +205,92 @@ defmodule CodexPooler.Gateway.RequestCompression.PerformanceTest do
       refute inspect(compression) =~ "call_oversized_shell_output"
     end
 
+    test "returns a large completed rewrite when a sibling candidate hits tokenizer input limit" do
+      rewrite_item = %{
+        "type" => "local_shell_call_output",
+        "call_id" => "call_near_limit_completed_rewrite",
+        "output" =>
+          oversized_log_fixture("near-limit shell", "SANITIZED_NEAR_LIMIT_REWRITE_SENTINEL")
+      }
+
+      skipped_output =
+        "[\n  " <>
+          Jason.encode!(
+            String.duplicate("a", TokenCounter.max_input_bytes() + 1) <>
+              "SANITIZED_NEAR_LIMIT_SKIP_SENTINEL"
+          ) <> "\n]"
+
+      skip_item = %{
+        "type" => "local_shell_call_output",
+        "call_id" => "call_near_limit_tokenizer_skip",
+        "output" => skipped_output
+      }
+
+      base_items = [rewrite_item, skip_item]
+      body = encode_request(base_items ++ [near_limit_padding_item(@max_body_bytes, base_items)])
+
+      assert byte_size(body) == @max_body_bytes
+
+      {context, request_options} = request_context()
+      started = System.monotonic_time(:millisecond)
+
+      assert {compressed_body, compressed_options} =
+               RequestCompression.maybe_compress(body, context, request_options)
+
+      elapsed_ms = System.monotonic_time(:millisecond) - started
+      compression = compressed_options.runtime.payload_compression
+
+      assert elapsed_ms <= @local_budget_ms
+      assert compressed_body != body
+
+      decoded_outputs =
+        compressed_body
+        |> Jason.decode!()
+        |> Map.fetch!("input")
+        |> Map.new(&{&1["call_id"], &1["output"]})
+
+      rewritten_output = Map.fetch!(decoded_outputs, "call_near_limit_completed_rewrite")
+      assert rewritten_output =~ "[compressed log output: omitted"
+      refute rewritten_output =~ "SANITIZED_NEAR_LIMIT_REWRITE_SENTINEL"
+
+      assert Map.fetch!(decoded_outputs, "call_near_limit_tokenizer_skip") == skipped_output
+
+      assert Map.fetch!(decoded_outputs, "call_near_limit_tokenizer_skip") =~
+               "SANITIZED_NEAR_LIMIT_SKIP_SENTINEL"
+
+      assert %{
+               "enabled" => true,
+               "attempted" => true,
+               "status" => "compressed",
+               "reason" => "rewritten",
+               "route_class" => "proxy_http",
+               "transport" => "http_json",
+               "candidate_count" => 2,
+               "compressed_count" => 1,
+               "skipped_count" => 1,
+               "tokenizer_input_skipped_count" => 1,
+               "original_bytes" => @max_body_bytes,
+               "compressed_bytes" => compressed_bytes,
+               "original_tokens_lower_bound" => original_tokens_lower_bound,
+               "compressed_tokens" => compressed_tokens
+             } = compression
+
+      assert compressed_bytes == byte_size(compressed_body)
+      assert compressed_bytes < @max_body_bytes
+      assert compression["token_count_mode"] == "bounded_original"
+      assert compressed_tokens < original_tokens_lower_bound
+      assert "log_output" in compression["strategies"]
+      assert finite_elapsed_ms?(compression)
+      refute Map.has_key?(compression, "original_tokens")
+      refute Map.has_key?(compression, "saved_tokens")
+      refute Map.has_key?(compression, "token_savings_ratio")
+      refute Map.has_key?(compression, "token_savings_percent")
+      refute inspect(compression) =~ "SANITIZED_NEAR_LIMIT_REWRITE_SENTINEL"
+      refute inspect(compression) =~ "SANITIZED_NEAR_LIMIT_SKIP_SENTINEL"
+      refute inspect(compression) =~ "call_near_limit_completed_rewrite"
+      refute inspect(compression) =~ "call_near_limit_tokenizer_skip"
+    end
+
     test "handles a sanitized one MiB fixture within the local dispatch budget" do
       body = fixed_size_request(@max_body_bytes, @max_candidate_count)
       {context, request_options} = request_context()
@@ -304,6 +396,17 @@ defmodule CodexPooler.Gateway.RequestCompression.PerformanceTest do
     body
   end
 
+  defp near_limit_padding_item(target_body_bytes, base_items) do
+    empty_padding_item = %{"type" => "message", "role" => "user", "content" => ""}
+    empty_body = encode_request(base_items ++ [empty_padding_item])
+    remaining_bytes = target_body_bytes - byte_size(empty_body)
+    padding = String.duplicate("p", remaining_bytes)
+    padding_item = %{empty_padding_item | "content" => padding}
+    body = encode_request(base_items ++ [padding_item])
+    assert byte_size(body) == target_body_bytes
+    padding_item
+  end
+
   defp plain_output(index, bytes) do
     prefix = "synthetic output #{index}: "
 
diff --git a/test/codex_pooler_web/controllers/v1/responses_controller_test.exs b/test/codex_pooler_web/controllers/v1/responses_controller_test.exs
@@ -2084,6 +2084,54 @@ defmodule CodexPoolerWeb.V1.ResponsesControllerTest do
     assert captured.json["store"] == false
   end
 
+  test "POST /v1/responses forwards indexed web search tool shape upstream", %{conn: conn} do
+    tool = %{
+      "type" => "web_search",
+      "external_web_access" => true,
+      "index_gated_web_access" => true
+    }
+
+    upstream =
+      start_upstream(
+        FakeUpstream.sse_stream([
+          {"response.completed",
+           %{
+             "type" => "response.completed",
+             "response" => %{
+               "id" => "resp_v1_indexed_web_search_tool",
+               "status" => "completed",
+               "output" => [
+                 %{
+                   "type" => "message",
+                   "content" => [%{"type" => "output_text", "text" => "indexed search accepted"}]
+                 }
+               ],
+               "usage" => %{"input_tokens" => 2, "output_tokens" => 3, "total_tokens" => 5}
+             }
+           }}
+        ])
+      )
+
+    setup = gateway_setup(upstream)
+
+    conn =
+      conn
+      |> auth(setup)
+      |> post("/v1/responses", %{
+        "model" => setup.model.exposed_model_id,
+        "input" => "synthetic indexed web search request",
+        "tools" => [tool]
+      })
+
+    assert %{"id" => "resp_v1_indexed_web_search_tool"} = json_response(conn, 200)
+
+    assert [captured] = FakeUpstream.requests(upstream)
+    assert captured.path == "/backend-api/codex/responses"
+    assert captured.json["tools"] == [tool]
+    assert captured.json["stream"] == true
+    assert captured.json["store"] == false
+  end
+
   test "POST /v1/responses keeps opencode continuity headers local without forwarding", %{
     conn: conn
   } do
