Address review: narrow allowance override, add suggestion_id conversion tests

1. should_accept_via_suggestion_allowance now only overrides the
   RequestLimitReached disabled state. Previously a positive suggestion
   allowance overrode force_enabled for every disabled PromptAlertState
   (NoConnection, DelinquentDueToPaymentIssue, anonymous hard gate,
   overage/spend policy), letting those Free users click a chip while
   blocked for unrelated reasons. Added regression coverage for all of
   those states.
2. Added conversion tests asserting suggestion_id actually survives:
   PromptChip extraction through convert_input_to_user_input onto the
   wire (with and without an offer id), and proto history through
   convert_passive_suggestion_result_to_input back into a restored
   AIAgentInput (with and without an offer id).

Author: warp-agent-staging[bot]

app/src/ai/agent/api/convert_conversation_tests.rs

@@ -8,7 +8,7 @@ use crate::ai::agent::api::convert_conversation::*;
 use crate::ai::agent::conversation::{
     AIAgentHarness, AIConversationId, ServerAIConversationMetadata,
 };
-use crate::ai::agent::{AIAgentInput, UserQueryMode};
+use crate::ai::agent::{AIAgentInput, PassiveSuggestionResultType, UserQueryMode};
 use crate::ai::ambient_agents::AmbientAgentTaskId;
 use crate::cloud_object::{Revision, ServerMetadata, ServerPermissions};
 use crate::persistence::model::ConversationUsageMetadata;
@@ -2242,3 +2242,79 @@ fn test_handoff_rehydration_system_query_is_hidden() {
         "Agent output should still be rendered"
     );
 }
+
+/// The `suggestion_id` is the entire anti-fraud capability behind the
+/// lifetime prompt-suggestion allowance: it must survive a round trip
+/// through persisted history back into a restored `AIAgentInput`.
+#[test]
+fn passive_suggestion_result_prompt_restores_offer_id_from_history() {
+    let passive_result = api::message::PassiveSuggestionResult {
+        result: Some(api::PassiveSuggestionResultType {
+            trigger: Some(
+                api::passive_suggestion_result_type::Trigger::AgentResponseCompleted(
+                    api::passive_suggestion_result_type::AgentResponseCompleted {},
+                ),
+            ),
+            suggestion: Some(api::passive_suggestion_result_type::Suggestion::Prompt(
+                api::passive_suggestion_result_type::Prompt {
+                    prompt: "do the thing".to_string(),
+                },
+            )),
+            suggestion_id: "offer-123".to_string(),
+        }),
+        context: None,
+    };
+
+    let input = convert_passive_suggestion_result_to_input(&passive_result)
+        .expect("should convert to an input");
+
+    match input {
+        AIAgentInput::PassiveSuggestionResult { suggestion, .. } => match suggestion {
+            PassiveSuggestionResultType::Prompt {
+                prompt,
+                suggestion_id,
+            } => {
+                assert_eq!(prompt, "do the thing");
+                assert_eq!(suggestion_id, Some("offer-123".to_string()));
+            }
+            other => panic!("Expected prompt suggestion, got {other:?}"),
+        },
+        other => panic!("Expected PassiveSuggestionResult input, got {other:?}"),
+    }
+}
+
+/// A chip with no live offer (legacy/static chip, or an old server) must not
+/// invent an id: an empty wire `suggestion_id` restores to `None`, not
+/// `Some("")`.
+#[test]
+fn passive_suggestion_result_prompt_with_absent_offer_id_restores_to_none() {
+    let passive_result = api::message::PassiveSuggestionResult {
+        result: Some(api::PassiveSuggestionResultType {
+            trigger: Some(
+                api::passive_suggestion_result_type::Trigger::AgentResponseCompleted(
+                    api::passive_suggestion_result_type::AgentResponseCompleted {},
+                ),
+            ),
+            suggestion: Some(api::passive_suggestion_result_type::Suggestion::Prompt(
+                api::passive_suggestion_result_type::Prompt {
+                    prompt: "static suggestion".to_string(),
+                },
+            )),
+            suggestion_id: String::new(),
+        }),
+        context: None,
+    };
+
+    let input = convert_passive_suggestion_result_to_input(&passive_result)
+        .expect("should convert to an input");
+
+    match input {
+        AIAgentInput::PassiveSuggestionResult { suggestion, .. } => match suggestion {
+            PassiveSuggestionResultType::Prompt { suggestion_id, .. } => {
+                assert_eq!(suggestion_id, None);
+            }
+            other => panic!("Expected prompt suggestion, got {other:?}"),
+        },
+        other => panic!("Expected PassiveSuggestionResult input, got {other:?}"),
+    }
+}

app/src/ai/agent/api/convert_to_tests.rs

@@ -1,11 +1,13 @@
+use std::sync::Arc;
+
 use chrono::{DateTime, Utc};
 use warp_core::command::ExitCode;
 use warp_multi_agent_api as api;
 
 use crate::ai::agent::task::TaskId;
 use crate::ai::agent::{
-    AIAgentActionResult, AIAgentActionResultType, AIAgentContext,
-    TransferShellCommandControlToUserResult,
+    AIAgentActionResult, AIAgentActionResultType, AIAgentContext, AIAgentInput,
+    PassiveSuggestionResultType, TransferShellCommandControlToUserResult,
 };
 use crate::terminal::model::block::BlockId;
 
@@ -157,6 +159,57 @@ fn transfer_control_snapshot_result_converts_to_tool_call_result_input() {
     }
 }
 
+#[test]
+fn passive_suggestion_result_prompt_carries_offer_id_onto_the_wire() {
+    let input = AIAgentInput::PassiveSuggestionResult {
+        trigger: None,
+        suggestion: PassiveSuggestionResultType::Prompt {
+            prompt: "do the thing".to_string(),
+            suggestion_id: Some("offer-123".to_string()),
+        },
+        context: Arc::new([]),
+    };
+
+    let converted = super::convert_input_to_user_input(input).expect("should convert");
+    match converted {
+        api::request::input::user_inputs::user_input::Input::PassiveSuggestionResult(input) => {
+            let result = input.result.expect("result should be set");
+            assert_eq!(result.suggestion_id, "offer-123");
+            match result.suggestion {
+                Some(api::passive_suggestion_result_type::Suggestion::Prompt(prompt)) => {
+                    assert_eq!(prompt.prompt, "do the thing");
+                }
+                other => panic!("Expected prompt suggestion, got {other:?}"),
+            }
+        }
+        other => panic!("Expected passive-suggestion-result input, got {other:?}"),
+    }
+}
+
+#[test]
+fn passive_suggestion_result_prompt_without_offer_id_sends_empty_suggestion_id() {
+    let input = AIAgentInput::PassiveSuggestionResult {
+        trigger: None,
+        suggestion: PassiveSuggestionResultType::Prompt {
+            prompt: "do the thing".to_string(),
+            suggestion_id: None,
+        },
+        context: Arc::new([]),
+    };
+
+    let converted = super::convert_input_to_user_input(input).expect("should convert");
+    match converted {
+        api::request::input::user_inputs::user_input::Input::PassiveSuggestionResult(input) => {
+            let result = input.result.expect("result should be set");
+            assert_eq!(
+                result.suggestion_id, "",
+                "a chip with no live offer must not invent an id"
+            );
+        }
+        other => panic!("Expected passive-suggestion-result input, got {other:?}"),
+    }
+}
+
 #[test]
 fn transfer_control_finished_result_converts_to_tool_call_result_input() {
     let block_id = BlockId::default();

app/src/terminal/view/inline_banner/prompt_suggestions.rs

@@ -346,11 +346,15 @@ fn should_open_unavailable_modal(state: &PromptAlertState, app: &AppContext) ->
 }
 
 /// Whether a click should accept the chip by drawing on the lifetime
-/// prompt-suggestion allowance instead of the interactive wallet. This is the
-/// gate PRODUCT.md requires: remaining > 0 must never open the interactive
-/// unavailable modal and must dispatch `ResolvePromptSuggestion` instead.
-fn should_accept_via_suggestion_allowance(app: &AppContext) -> bool {
-    AIRequestUsageModel::as_ref(app).can_accept_prompt_suggestion()
+/// prompt-suggestion allowance instead of the interactive wallet. Only ever
+/// overrides the `RequestLimitReached` disabled state -- every other
+/// disabled state (offline, delinquent, anonymous hard gate, overage/spend
+/// policy) keeps its own disabled treatment and tooltip regardless of
+/// suggestion credits, per PRODUCT.md's "remaining > 0 and the other accept
+/// rules passing" gate.
+fn should_accept_via_suggestion_allowance(state: &PromptAlertState, app: &AppContext) -> bool {
+    matches!(state, PromptAlertState::RequestLimitReached)
+        && AIRequestUsageModel::as_ref(app).can_accept_prompt_suggestion()
 }
 
 #[derive(Debug, Clone, PartialEq, Eq)]
@@ -427,7 +431,8 @@ impl View for PromptSuggestionsView {
 
         let prompt_alert_state = self.prompt_alert.as_ref(app).state();
         let open_unavailable_modal = should_open_unavailable_modal(prompt_alert_state, app);
-        let can_accept_via_suggestion_allowance = should_accept_via_suggestion_allowance(app);
+        let can_accept_via_suggestion_allowance =
+            should_accept_via_suggestion_allowance(prompt_alert_state, app);
         // Only relevant when the disablement reason is the shared
         // "out of requests" state; other disabled states (offline, payment
         // issues) keep their own, higher-priority tooltip.

app/src/terminal/view/inline_banner/prompt_suggestions_tests.rs

@@ -73,13 +73,50 @@ fn should_open_unavailable_modal_is_false_when_suggestion_remaining_is_positive(
                 "remaining > 0 must never open the interactive unavailable modal"
             );
             assert!(
-                should_accept_via_suggestion_allowance(ctx),
+                should_accept_via_suggestion_allowance(&PromptAlertState::RequestLimitReached, ctx),
                 "remaining > 0 must allow the accept to go through"
             );
         });
     })
 }
 
+/// PRODUCT.md gates the click on remaining > 0 *and* the other accept rules
+/// passing: a positive suggestion allowance must not override any disabled
+/// state besides `RequestLimitReached`. Free users who are offline or
+/// delinquent must stay blocked (with their own tooltip) even with credits.
+#[test]
+fn should_accept_via_suggestion_allowance_is_false_for_other_disabled_states_even_with_remaining() {
+    App::test((), |mut app| async move {
+        let _flag = FeatureFlag::OpenWarpNewSettingsModes.override_enabled(true);
+        initialize_app_with_allowance(
+            &mut app,
+            Some(PromptSuggestionAllowance {
+                limit: 300,
+                used: 100,
+            }),
+        );
+
+        app.read(|ctx| {
+            for state in [
+                PromptAlertState::NoConnection,
+                PromptAlertState::DelinquentDueToPaymentIssue,
+                PromptAlertState::AnonymousUserRequestLimitHardGate,
+                PromptAlertState::OveragesToggleableButNotEnabled,
+                PromptAlertState::MonthlyOveragesSpendLimitReached,
+            ] {
+                assert!(
+                    !should_accept_via_suggestion_allowance(&state, ctx),
+                    "a positive suggestion allowance must not override the {state:?} disabled state"
+                );
+                assert!(
+                    !should_open_unavailable_modal(&state, ctx),
+                    "the interactive unavailable modal is specific to RequestLimitReached, not {state:?}"
+                );
+            }
+        });
+    })
+}
+
 #[test]
 fn should_open_unavailable_modal_is_false_when_suggestion_allowance_is_exhausted() {
     App::test((), |mut app| async move {
@@ -99,7 +136,10 @@ fn should_open_unavailable_modal_is_false_when_suggestion_allowance_is_exhausted
                 &PromptAlertState::RequestLimitReached,
                 ctx
             ));
-            assert!(!should_accept_via_suggestion_allowance(ctx));
+            assert!(!should_accept_via_suggestion_allowance(
+                &PromptAlertState::RequestLimitReached,
+                ctx
+            ));
         });
     })
 }
@@ -118,7 +158,10 @@ fn should_open_unavailable_modal_is_true_when_no_suggestion_allowance_exists() {
                 &PromptAlertState::RequestLimitReached,
                 ctx
             ));
-            assert!(!should_accept_via_suggestion_allowance(ctx));
+            assert!(!should_accept_via_suggestion_allowance(
+                &PromptAlertState::RequestLimitReached,
+                ctx
+            ));
         });
     })
 }