myAI BDC DEVELOPER PORTAL

import requests
import json
import asyncio
from typing import Optional, Dict, Any

# Configuration
API_ENDPOINT = '{YOUR_API_ENDPOINT}/api/v1'
API_KEY = 'YOUR_API_KEY'

class BDCClient:
    def __init__(self, api_key: str):
        self.api_key = api_key
        self.headers = {
            'Authorization': f'Bearer {api_key}',
            'Content-Type': 'application/json'
        }
    
    def search_products(self, query: str, 
                         enable_parlay: bool = True,
                         filters: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:
        """Search for products with optional Parlay negotiation"""
        
        payload = {
            'buyerAgentId': 'my-agent-123',
            'query': query,
            'enableParlay': enable_parlay
        }
        
        if filters:
            payload['filters'] = filters
        
        response = requests.post(
            f'{API_ENDPOINT}/products/search',
            headers=self.headers,
            json=payload
        )
        response.raise_for_status()
        return response.json()
    
    def initiate_parlay(self, product_id: str, 
                        initial_offer: float,
                        context: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:
        """Start a Parlay negotiation for a product"""
        
        payload = {
            'productId': product_id,
            'buyerAgentId': 'my-agent-123',
            'initialOffer': initial_offer
        }
        
        if context:
            payload['context'] = context
        
        response = requests.post(
            f'{API_ENDPOINT}/parlay/initiate',
            headers=self.headers,
            json=payload
        )
        response.raise_for_status()
        return response.json()
    
    def counter_offer(self, session_id: str, 
                       new_offer: float) -> Dict[str, Any]:
        """Submit a counter offer in an active Parlay session"""
        
        response = requests.post(
            f'{API_ENDPOINT}/parlay/{session_id}/counter',
            headers=self.headers,
            json={'offer': new_offer}
        )
        response.raise_for_status()
        return response.json()

# Example: Automated negotiation bot
async def negotiate_best_price(client: BDCClient, product_id: str, 
                               target_price: float, max_rounds: int = 5):
    """Automatically negotiate to reach target price"""
    
    # Start negotiation at 80% of listing price
    initial_offer = target_price * 0.8
    
    parlay = client.initiate_parlay(
        product_id=product_id,
        initial_offer=initial_offer,
        context={
            'orderQuantity': 10,
            'customerType': 'business'
        }
    )
    
    session_id = parlay['sessionId']
    rounds = 0
    
    while rounds < max_rounds and parlay['status'] == 'negotiating':
        current_price = parlay['currentOffer']['price']
        
        if current_price <= target_price:
            # Accept the offer
            response = requests.post(
                f'{API_ENDPOINT}/parlay/{session_id}/accept',
                headers=client.headers
            )
            print(f"Deal accepted at ${current_price}!")
            break
        
        # Counter with gradual increase
        new_offer = initial_offer + (
            (target_price - initial_offer) * (rounds + 1) / max_rounds
        )
        
        parlay = client.counter_offer(session_id, new_offer)
        rounds += 1
        
        await asyncio.sleep(2)  # Wait between rounds
    
    return parlay

# Usage example
if __name__ == '__main__':
    client = BDCClient(API_KEY)
    
    # Search for negotiable products
    results = client.search_products(
        query='premium office chairs',
        enable_parlay=True
    )
    
    parlay_products = [p for p in results['products'] if p['parlayEnabled']]
    
    print(f"Found {len(parlay_products)} negotiable products")
    
    if parlay_products:
        # Start negotiation on first product
        product = parlay_products[0]
        target = product['price'] * 0.85  # Target 15% discount
        
        asyncio.run(negotiate_best_price(
            client, product['id'], target
        ))

#!/bin/bash

# Set your API credentials
API_ENDPOINT="{YOUR_API_ENDPOINT}/api/v1"
API_KEY="YOUR_API_KEY"

# Search for products with Parlay enabled
curl -X POST "${API_ENDPOINT}/products/search" \
  -H "Authorization: Bearer ${API_KEY}" \
  -H "Content-Type: application/json" \
  -d '{
    "buyerAgentId": "my-agent-123",
    "query": "office chairs",
    "enableParlay": true
  }'

# Initiate a Parlay negotiation
PRODUCT_ID="prod_123"
INITIAL_OFFER="150.00"

PARLAY_RESPONSE=$(curl -s -X POST "${API_ENDPOINT}/parlay/initiate" \
  -H "Authorization: Bearer ${API_KEY}" \
  -H "Content-Type: application/json" \
  -d '{
    "productId": "'${PRODUCT_ID}'",
    "buyerAgentId": "my-agent-123",
    "initialOffer": '${INITIAL_OFFER}',
    "context": {
      "orderQuantity": 5,
      "customerType": "business"
    }
  }')

# Extract session ID using jq
SESSION_ID=$(echo "$PARLAY_RESPONSE" | jq -r '.sessionId')
echo "Negotiation started. Session ID: $SESSION_ID"

# Check negotiation status
curl -X GET "${API_ENDPOINT}/parlay/${SESSION_ID}/status" \
  -H "Authorization: Bearer ${API_KEY}" | jq '.'

# Submit counter offer
curl -X POST "${API_ENDPOINT}/parlay/${SESSION_ID}/counter" \
  -H "Authorization: Bearer ${API_KEY}" \
  -H "Content-Type: application/json" \
  -d '{
    "offer": 165.00
  }'

# Accept current offer
curl -X POST "${API_ENDPOINT}/parlay/${SESSION_ID}/accept" \
  -H "Authorization: Bearer ${API_KEY}" \
  -H "Content-Type: application/json" \
  -d '{}'

# Full negotiation workflow example
negotiate_product() {
  local product_id="$1"
  local target_price="$2"
  
  # Start negotiation at 80% of target
  local initial_offer=$(echo "$target_price * 0.8" | bc)
  
  echo "Starting negotiation for product $product_id"
  echo "Target price: $target_price, Initial offer: $initial_offer"
  
  # Initiate parlay and get session ID
  local session_response=$(curl -s -X POST "${API_ENDPOINT}/parlay/initiate" \
    -H "Authorization: Bearer ${API_KEY}" \
    -H "Content-Type: application/json" \
    -d "{
      \"productId\": \"$product_id\",
      \"buyerAgentId\": \"my-agent-123\",
      \"initialOffer\": $initial_offer
    }")
  
  local session_id=$(echo "$session_response" | jq -r '.sessionId')
  
  # Negotiation loop
  for i in {1..5}; do
    sleep 2
    
    # Check current status
    local status_response=$(curl -s -X GET \
      "${API_ENDPOINT}/parlay/${session_id}/status" \
      -H "Authorization: Bearer ${API_KEY}")
    
    local current_price=$(echo "$status_response" | \
      jq -r '.currentOffer.price')
    
    echo "Round $i: Current offer is $current_price"
    
    # Accept if price is good
    if (( $(echo "$current_price <= $target_price" | bc -l) )); then
      echo "Accepting offer at $current_price!"
      curl -s -X POST "${API_ENDPOINT}/parlay/${session_id}/accept" \
        -H "Authorization: Bearer ${API_KEY}" \
        -d '{}'
      break
    fi
    
    # Counter offer
    local new_offer=$(echo "$initial_offer + ($target_price - $initial_offer) * $i / 5" | bc)
    echo "Countering with $new_offer"
    
    curl -s -X POST "${API_ENDPOINT}/parlay/${session_id}/counter" \
      -H "Authorization: Bearer ${API_KEY}" \
      -H "Content-Type: application/json" \
      -d "{\"offer\": $new_offer}"
  done
}

# Example usage
negotiate_product "prod_456" "175.00"