Order Updates

You are calling from QuickShip Logistics to provide an order update. You have the following order information:

Order: #{{ORDER_ID}}
Customer: {{CUSTOMER_NAME}}
Status: {{ORDER_STATUS}}
Estimated Delivery: {{DELIVERY_DATE}}
Items: {{ITEMS}}

Purpose of call:
- Confirm delivery time window
- Verify delivery address
- Handle any special instructions
- Reschedule if needed

Be proactive, helpful, and efficient. If there's an issue (delay, missing item), apologize and offer solutions.

app.post('/webhook/orders', async (req, res) => {
  const { tool_name, parameters, call_id } = req.body;
  
  switch (tool_name) {
    case 'get_order_details':
      const order = await db.orders.findById(parameters.order_id);
      const tracking = await shipping.getTracking(order.tracking_number);
      return res.json({
        order_id: order.id,
        status: tracking.status,
        estimated_delivery: tracking.estimated_delivery,
        current_location: tracking.current_location,
        items: order.items,
        address: order.shipping_address
      });
      
    case 'confirm_delivery':
      await db.orders.update(parameters.order_id, {
        delivery_confirmed: true,
        confirmed_date: parameters.confirmed_date,
        time_window: parameters.time_window,
        special_instructions: parameters.special_instructions
      });
      
      // Update delivery driver app
      await driverApp.updateDelivery(parameters.order_id, {
        instructions: parameters.special_instructions
      });
      
      // Send SMS confirmation
      await twilio.messages.create({
        to: order.customer_phone,
        body: `Delivery confirmed for ${parameters.confirmed_date} between ${parameters.time_window}`
      });
      
      return res.json({ success: true, confirmed: true });
      
    case 'reschedule_delivery':
      const newSlot = await shipping.reschedule({
        order_id: parameters.order_id,
        date: parameters.new_date,
        time_preference: parameters.new_time_preference
      });
      
      await db.orders.update(parameters.order_id, {
        delivery_date: newSlot.date,
        time_window: newSlot.time_window,
        reschedule_reason: parameters.reason
      });
      
      return res.json({
        success: true,
        new_date: newSlot.date,
        new_time_window: newSlot.time_window
      });
      
    case 'update_address':
      // Validate address
      const validated = await addressValidator.validate(parameters.new_address);
      if (!validated.valid) {
        return res.json({ success: false, error: 'Invalid address', suggestions: validated.suggestions });
      }
      
      await db.orders.update(parameters.order_id, {
        shipping_address: validated.formatted_address,
        address_type: parameters.address_type
      });
      
      return res.json({ success: true, formatted_address: validated.formatted_address });
      
    case 'report_issue':
      const ticket = await db.support_tickets.create({
        order_id: parameters.order_id,
        type: parameters.issue_type,
        description: parameters.description,
        resolution_preference: parameters.resolution_preference,
        priority: 'high',
        status: 'open'
      });
      
      // Auto-process refunds/replacements for certain issue types
      if (parameters.resolution_preference === 'replacement') {
        await fulfillment.createReplacementOrder(parameters.order_id);
      }
      
      return res.json({
        success: true,
        ticket_id: ticket.id,
        message: `Ticket #${ticket.id} created. ${parameters.resolution_preference} will be processed within 24 hours.`
      });
  }
});