Before an Agent Pays, It Negotiates. Before It Negotiates, It Needs a Communication Channel.

# The agentic commerce transaction lifecycle:

# Phase 1: COMMUNICATION (agent-to-agent/agent-to-merchant)
discovery = agent.find_vendors(category="cloud_compute", region="us-east")
# → Requires: structured messaging, vendor discovery, capability exchange

quotes = agent.request_quotes(vendors=discovery.results, specs=requirements)
# → Requires: real-time message exchange, schema validation

negotiation = agent.negotiate(
    vendor=quotes.best_match,
    target_price=budget * 0.8,
    constraints={"sla": "99.9%", "payment_terms": "net_30"}
)
# → Requires: multi-turn conversation, state management, timeout handling

agreement = agent.confirm_terms(negotiation.final_offer)
# → Requires: consensus, acknowledgment, contract formation

# Phase 2: PAYMENT (only after communication succeeds)
payment = agent.execute_payment(
    amount=agreement.price,
    vendor=agreement.vendor_id,
    authorization=governance.check(agreement)
)
# → Requires: identity, authorization, budget check, settlement

# The problem: Phase 1 and Phase 2 use DIFFERENT infrastructure
# Communication: ad-hoc HTTP calls, no standard messaging layer
# Payment: wallet + authorization layer
# Gap: no unified lifecycle management across both phases

# Failure Mode 1: Negotiation succeeds, payment fails
# Agent negotiated a $450 deal. Budget was $500.
# Between negotiation and payment: another agent spent $100.
# Remaining budget: $400. Payment denied.
# Vendor already reserved inventory. Now needs to be notified.
# Communication channel: already closed after negotiation.
# Result: ghost reservation, vendor frustrated, no way to renegotiate.

# Failure Mode 2: Payment authorized, communication lost
# Agent got budget approval for $450 purchase.
# Sends payment confirmation to vendor.
# Vendor never receives confirmation (message lost).
# Vendor cancels the deal after timeout.
# Agent's budget: $450 already reserved.
# Result: locked budget, no purchase, manual cleanup needed.

# Failure Mode 3: Mid-negotiation governance change
# Agent is in round 3 of price negotiation.
# Finance team reduces daily budget from $5000 to $2000.
# Agent doesn't know (communication and governance are separate).
# Agent agrees to $3000 deal.
# Payment: denied.
# Result: broken agreement, reputation damage, legal exposure.

# With unified rosud-pay + rosud-call:
from rosud_pay import Governance
from rosud_call import Channel

# Unified lifecycle: communication + payment in one managed flow
channel = Channel.create(
    participants=["procurement_bot", "vendor_agent"],
    governance=Governance.attach(
        # Payment governance is LIVE during negotiation
        budget_check="real_time",  # Not just at payment time
        on_budget_change="notify_agent_immediately",
        on_negotiation_exceeds_budget="interrupt_and_renegotiate"
    )
)

# Agent negotiates WITH governance awareness:
negotiation = await channel.negotiate(
    target_price=450,
    max_price=channel.governance.available_budget,  # Always current
    on_budget_insufficient="counter_offer_lower"
)
# If budget changes mid-negotiation: agent knows instantly
# If payment will fail: agent knows BEFORE agreeing to terms
# If message is lost: channel retries with confirmation

# Simple case (x402 handles):
# Agent requests resource → pays → gets access
# One message, one payment, done.

# Enterprise case (needs unified communication + payment):
# Agent discovers 5 vendors → requests quotes from all 5
# → Negotiates with top 3 → Agrees with 1 → Executes payment
# → Monitors delivery → Disputes if SLA violated → Resolves

# This lifecycle spans:
# - 15+ messages (discovery, quotes, negotiation rounds)
# - 1-3 payments (deposit, milestone, final)
# - 1 governance session (budget tracked throughout)
# - Potential dispute resolution (requires communication + refund)

# Duration: minutes to days (not milliseconds)
# State: must persist across all phases
# Governance: must be live throughout (not just at payment)

from rosud_call import CommercePipeline
from rosud_pay import PaymentLifecycle

pipeline = CommercePipeline.create(
    buyer="procurement_bot",
    payment=PaymentLifecycle(
        # Budget is tracked from FIRST message, not just payment
        budget_tracking="from_negotiation_start",
        # Governance events flow through the communication channel
        governance_events="inline",
        # Payment and communication share state
        shared_state=True,
        # If communication fails, payment is automatically held
        on_comm_failure="hold_payment",
        # If payment fails, vendor is automatically notified
        on_payment_failure="notify_via_channel"
    )
)