feat(gateway): expand request compression coverage

- add lossless JSON object compression and broader diagnostic log detection

- keep request-log compression badges token-only and suppress zero savings

Author: masterkain

README.md

@@ -1345,11 +1345,7 @@ admin, MCP, usage, and control-plane requests are not eligible; public
 dispatch.
 
 Request compression is request-side only. Codex Pooler does not store raw tool
-outputs, does not store raw response bodies, and does not implement
-CCR/retrieval. Request logs may show `payload_compression` metadata with safe
-aggregate savings only, preferring saved token count and percent when local
-token counts are available and falling back to byte savings when token counts
-are unavailable.
+outputs or raw response bodies.
 
 ## Operator MCP Service
 

lib/codex_pooler/accounting/metadata.ex

@@ -54,6 +54,7 @@ defmodule CodexPooler.Accounting.Metadata do
   @payload_compression_strategy_names ~w(
                                          diff
                                          json_array_lossless
+                                         json_document_lossless
                                          log_output
                                          search_results
                                        )

lib/codex_pooler/accounting/request_logs.ex

@@ -576,8 +576,9 @@ defmodule CodexPooler.Accounting.RequestLogs do
   end
 
   defp payload_compression_metric_available?(saved, percent, original, compressed) do
-    is_integer(saved) and is_number(percent) and is_integer(original) and is_integer(compressed) and
-      original > 0
+    is_integer(saved) and saved > 0 and is_number(percent) and percent > 0 and
+      is_integer(original) and original > 0 and is_integer(compressed) and compressed >= 0 and
+      compressed < original
   end
 
   defp maybe_put_saved_count(metadata, original_key, compressed_key, saved_key) do

lib/codex_pooler/gateway/payloads/request_options.ex

@@ -103,6 +103,7 @@ defmodule CodexPooler.Gateway.Payloads.RequestOptions do
                                         search_results
                                         diff
                                         json_array_lossless
+                                        json_document_lossless
                                       )
   @safe_payload_compression_value ~r/\A[a-zA-Z0-9_.:-]+\z/
 

lib/codex_pooler/gateway/request_compression.ex

@@ -13,6 +13,7 @@ defmodule CodexPooler.Gateway.RequestCompression do
   @strategy_modules %{
     diff: Strategies.Diff,
     json_array_lossless: Strategies.JsonArrayLossless,
+    json_document_lossless: Strategies.JsonDocumentLossless,
     log_output: Strategies.LogOutput,
     search_results: Strategies.SearchResults
   }

lib/codex_pooler/gateway/request_compression/content_detector.ex

@@ -1,8 +1,10 @@
 defmodule CodexPooler.Gateway.RequestCompression.ContentDetector do
   @moduledoc false
 
-  @type kind :: :json_array | :diff | :html | :search | :build | :source_code | :text
-  @type strategy :: :json_array_lossless | :diff | :search_results | :log_output
+  @type kind ::
+          :json_array | :json_document | :diff | :html | :search | :build | :source_code | :text
+  @type strategy ::
+          :json_array_lossless | :json_document_lossless | :diff | :search_results | :log_output
   @type decision :: %{
           required(:kind) => kind(),
           required(:confidence) => float(),
@@ -12,6 +14,7 @@ defmodule CodexPooler.Gateway.RequestCompression.ContentDetector do
 
   @strategies %{
     json_array: :json_array_lossless,
+    json_document: :json_document_lossless,
     diff: :diff,
     search: :search_results,
     build: :log_output
@@ -39,6 +42,9 @@ defmodule CodexPooler.Gateway.RequestCompression.ContentDetector do
   @build_term_regex ~r/\b(?:build|building|compile|compiling|compiled|test|tests|failed|failure|running|finished|warning|error|npm|yarn|pnpm|mix|make|cargo|gradle|maven|pytest|rspec|exunit)\b/i
   @build_prefix_regex ~r/^\s*(?:\$ |==>|-->|Compiling|Running|Finished|warning:|error:|\[\w+\])/mi
   @stack_line_regex ~r/(?:^\s+at\s+\S+|^\s*File\s+"[^"]+",\s+line\s+\d+|^\s*\S+:\d+:\d+:)/m
+  @diagnostic_path_regex ~r/^\s*\S+\.(?:c|cc|cpp|cs|css|ex|exs|go|h|hpp|html|java|js|jsx|json|kt|m|md|mjs|mm|php|py|rb|rs|scss|svelte|swift|toml|ts|tsx|vue|xml|ya?ml)(?:\(\d+,\d+\)|:\d+(?::\d+)?)[:\s].+/im
+  @diagnostic_summary_regex ~r/^\s*(?:Build\s+(?:FAILED|succeeded)|BUILD\s+(?:FAILED|SUCCESSFUL)|\*\*\s+BUILD\s+(?:FAILED|SUCCEEDED)\s+\*\*|Failed!\s+-\s+Failed:|Passed!\s+-\s+Failed:|Test summary:|Found\s+\d+\s+(?:errors?|warnings?)|Executed\s+\d+\s+tests?,\s+with\s+\d+|\d+\s+(?:Warning|Error)\(s\)|\d+\s+(?:tests?|examples?)\s+(?:completed|run|passed|failed)|\d+\s+actionable tasks?:)/im
+  @lint_rule_regex ~r/\b(?:lint|style|correctness|suspicious|complexity|nursery|performance|security)\/[a-z0-9_\/-]+\b/i
 
   @source_keyword_regex ~r/^\s*(?:defmodule|defp?\s+\w+|class\s+\w+|function\s+\w+|import\s+|export\s+|const\s+\w+|let\s+\w+|var\s+\w+|pub\s+fn\s+\w+|fn\s+\w+|impl\s+\w+|module\s+\w+|alias\s+)/m
   @source_punctuation_regex ~r/[{}();]/
@@ -58,6 +64,9 @@ defmodule CodexPooler.Gateway.RequestCompression.ContentDetector do
       json_array?(trimmed) ->
         decision(:json_array, 100)
 
+      json_document?(trimmed) ->
+        decision(:json_document, 100)
+
       (points = diff_points(content)) >= 70 ->
         decision(:diff, points)
 
@@ -100,6 +109,13 @@ defmodule CodexPooler.Gateway.RequestCompression.ContentDetector do
     end
   end
 
+  defp json_document?(content) do
+    case Jason.decode(content) do
+      {:ok, value} when is_map(value) -> true
+      _other -> false
+    end
+  end
+
   defp diff_points(content) do
     [
       score(regex_match?(@diff_git_regex, content), 25),
@@ -151,9 +167,14 @@ defmodule CodexPooler.Gateway.RequestCompression.ContentDetector do
   defp build_points(content) do
     lines = lines(content)
     severities = scan_count(@severity_regex, content)
+    diagnostic_paths = scan_count(@diagnostic_path_regex, content)
+    diagnostic_summaries = scan_count(@diagnostic_summary_regex, content)
 
     [
       cond_score(severities, [{2, 30}, {1, 20}]),
+      cond_score(diagnostic_paths, [{2, 35}, {1, 25}]),
+      cond_score(diagnostic_summaries, [{2, 25}, {1, 15}]),
+      score(regex_match?(@lint_rule_regex, content), 15),
       score(regex_match?(@build_term_regex, content), 20),
       score(regex_match?(@build_prefix_regex, content), 20),
       score(regex_match?(@stack_line_regex, content), 25),

lib/codex_pooler/gateway/request_compression/strategies/json_document_lossless.ex

@@ -0,0 +1,37 @@
+defmodule CodexPooler.Gateway.RequestCompression.Strategies.JsonDocumentLossless do
+  @moduledoc """
+  Conservative JSON-object request compression.
+
+  This strategy only minifies valid top-level JSON object text and returns a
+  rewrite when local token counting proves a strict reduction. Arrays keep using
+  the existing array strategy so row-oriented metadata stays stable.
+  """
+
+  alias CodexPooler.Gateway.RequestCompression.Strategies
+
+  @strategy :json_document_lossless
+
+  @spec compress(term(), Strategies.opts()) :: Strategies.result()
+  def compress(content, opts \\ [])
+
+  def compress(content, opts) when is_binary(content) do
+    with {:ok, %Jason.OrderedObject{} = document} <-
+           Jason.decode(content, objects: :ordered_objects),
+         {:ok, compressed} <- Jason.encode(document) do
+      Strategies.finalize(
+        @strategy,
+        content,
+        compressed,
+        %{top_level_key_count: top_level_key_count(document)},
+        opts
+      )
+    else
+      {:error, :tokenizer_input_limit} -> {:skip, :tokenizer_input_limit}
+      _skip -> :skip
+    end
+  end
+
+  def compress(_content, _opts), do: :skip
+
+  defp top_level_key_count(%Jason.OrderedObject{values: values}), do: length(values)
+end

lib/codex_pooler/gateway/request_compression/strategies/log_output.ex

@@ -11,7 +11,7 @@ defmodule CodexPooler.Gateway.RequestCompression.Strategies.LogOutput do
   @default_context_lines 2
   @default_max_important_lines 12
 
-  @important_line_regex ~r/(?:^|\b)(?:error|warning|warn|failed|failure|fatal|panic|exception|traceback|assertion|exit\s+code|caused\s+by)(?:\b|:)/i
+  @important_line_regex ~r/(?:^|\b)(?:error|warning|warn|failed|failure|fatal|panic|exception|traceback|assertion|exit\s+code|caused\s+by)(?:\b|:)|^\s*(?:Build\s+(?:FAILED|succeeded)|BUILD\s+(?:FAILED|SUCCESSFUL)|\*\*\s+BUILD\s+(?:FAILED|SUCCEEDED)\s+\*\*|Failed!\s+-\s+Failed:|Passed!\s+-\s+Failed:|Test summary:|Found\s+\d+\s+(?:errors?|warnings?)|Executed\s+\d+\s+tests?,\s+with\s+\d+|\d+\s+(?:Warning|Error)\(s\)|\d+\s+(?:tests?|examples?)\s+(?:completed|run|passed|failed)|\d+\s+actionable tasks?:)/i
 
   @spec compress(term(), Strategies.opts()) :: Strategies.result()
   def compress(content, opts \\ [])

lib/codex_pooler_web/live/admin/components/pages/pools/wizard_components.ex

@@ -254,7 +254,7 @@ defmodule CodexPoolerWeb.Admin.PoolWizardComponents do
                         label="Request compression"
                       />
                       <p class="routing-option-help">
-                        Compress upstream-bound Responses tool outputs before dispatch.
+                        Shrinks eligible Responses tool outputs before upstream dispatch.
                       </p>
                     </div>
                   </div>

lib/codex_pooler_web/live/admin/components/pages/request_logs/display.ex

@@ -162,11 +162,12 @@ defmodule CodexPoolerWeb.Admin.RequestLogsDisplay do
 
   def compression_savings_line(%{payload_compression: compression})
       when is_map(compression) do
-    with unit when unit in ["tokens", "bytes"] <- Map.get(compression, :unit),
+    with "tokens" <- Map.get(compression, :unit),
          saved when is_integer(saved) <- Map.get(compression, :saved_count),
          percent when is_number(percent) <- Map.get(compression, :savings_percent),
-         ratio when is_number(ratio) <- Map.get(compression, :compression_ratio) do
-      "compression saved #{format_compression_count(saved, unit)} (#{format_percent(percent)}) · #{format_compression_ratio(ratio, unit)}"
+         ratio when is_number(ratio) <- Map.get(compression, :compression_ratio),
+         true <- saved > 0 and ratio < 1 do
+      "#{format_compression_count(saved)} (#{format_percent(percent)})"
     else
       _value -> nil
     end
@@ -185,7 +186,8 @@ defmodule CodexPoolerWeb.Admin.RequestLogsDisplay do
       compression_count_title_part(
         "tokenizer input skipped",
         Map.get(compression, :tokenizer_input_skipped_count)
-      )
+      ),
+      "percent is measured against rewritten tool-output candidates, not total request tokens"
     ]
     |> Enum.reject(&is_nil/1)
     |> case do
@@ -470,11 +472,7 @@ defmodule CodexPoolerWeb.Admin.RequestLogsDisplay do
 
   defp compact_cached_input_cost(_usd), do: nil
 
-  defp format_compression_count(saved, "tokens"), do: "#{Format.token_count(saved)} tokens"
-  defp format_compression_count(saved, "bytes"), do: "#{Format.integer(saved)} bytes"
-
-  defp format_compression_ratio(ratio, "bytes"), do: "byte ratio #{format_decimal(ratio)}x"
-  defp format_compression_ratio(ratio, _unit), do: "ratio #{format_decimal(ratio)}x"
+  defp format_compression_count(saved), do: Format.token_count(saved)
 
   defp format_percent(percent), do: "#{format_decimal(percent)}%"