Multi-Turn Conversations: Building B2B Product AI That Remembers Context

interface Turn {
  role: 'user' | 'assistant'
  content: string
  timestamp: number
}
 
class ConversationBuffer {
  private turns: Turn[] = []
  private maxTurns: number
 
  constructor(maxTurns = 6) {
    this.maxTurns = maxTurns
  }
 
  add(role: Turn['role'], content: string) {
    this.turns.push({ role, content, timestamp: Date.now() })
    if (this.turns.length > this.maxTurns * 2) {
      // maxTurns pairs (user + assistant)
      this.turns = this.turns.slice(-this.maxTurns * 2)
    }
  }
 
  format(): string {
    return this.turns
      .map((t) => `${t.role === 'user' ? 'Buyer' : 'Assistant'}: ${t.content}`)
      .join('\n')
  }
}

interface SessionContext {
  // Products currently in focus
  focusedProducts: ProductRef[]
 
  // Attributes the buyer has established as requirements
  activeFilters: {
    material?: string[]
    category?: string
    priceRange?: { min?: number; max?: number }
    deliveryRequirement?: string
    quantity?: number
  }
 
  // Buyer's stated intent / stage
  intent: 'exploring' | 'comparing' | 'specifying' | 'ready-to-order'
 
  // Items added to a notional cart or shortlist
  shortlist: ProductRef[]
 
  // Open questions / ambiguities we need to resolve
  pendingClarifications: string[]
}

async function extractSessionUpdates(
  userMessage: string,
  assistantResponse: string,
  currentContext: SessionContext
): Promise<Partial<SessionContext>> {
  const prompt = `
You are extracting structured information from a B2B product conversation turn.
 
Current session context: ${JSON.stringify(currentContext)}
 
Latest exchange:
Buyer: ${userMessage}
Assistant: ${assistantResponse}
 
Extract any updates to the session context. Return a JSON object with only the fields that changed:
- focusedProducts: products now in focus (with id and name)
- activeFilters: requirements the buyer stated or confirmed
- intent: buyer's current stage (exploring/comparing/specifying/ready-to-order)
- shortlist: products the buyer expressed interest in keeping
- pendingClarifications: unresolved ambiguities we should address
 
Return only changed fields. Return null for no changes.
`
 
  const result = await llm.complete({ user: prompt, format: 'json' })
  return result ?? {}
}

async function rewriteQuery(
  userMessage: string,
  buffer: ConversationBuffer,
  sessionContext: SessionContext
): Promise<string> {
  const prompt = `
You are preparing a search query for a B2B product catalog.
 
Recent conversation:
${buffer.format()}
 
Session context:
- Currently discussing: ${sessionContext.focusedProducts.map((p) => p.name).join(', ') || 'nothing specific'}
- Active requirements: ${JSON.stringify(sessionContext.activeFilters)}
 
Latest user message: "${userMessage}"
 
Rewrite this message as a complete, standalone search query that includes all relevant context.
The query will be used to search a product catalog — be specific and include technical terms.
Return only the rewritten query, nothing else.
`
 
  return llm.complete({ user: prompt })
}

async function resolveProductRefs(
  userMessage: string,
  sessionContext: SessionContext
): Promise<ProductRef[]> {
  // If no pronouns/vague references, no resolution needed
  const vagueTerms = ['it', 'those', 'them', 'that', 'these', 'the ones', 'the same']
  const hasVagueTerm = vagueTerms.some((t) =>
    userMessage.toLowerCase().includes(t)
  )
 
  if (!hasVagueTerm || sessionContext.focusedProducts.length === 0) {
    return []
  }
 
  // Return currently focused products as the resolution
  return sessionContext.focusedProducts
}
 
async function buildRetrievalQuery(
  userMessage: string,
  sessionContext: SessionContext,
  buffer: ConversationBuffer
): Promise<{ query: string; filters?: Record<string, unknown> }> {
  const resolvedProducts = await resolveProductRefs(userMessage, sessionContext)
 
  // Build a hybrid retrieval request: semantic query + metadata filters
  const query = await rewriteQuery(userMessage, buffer, sessionContext)
 
  const filters: Record<string, unknown> = {}
 
  // If we've resolved to specific products, add metadata filter to anchor retrieval
  if (resolvedProducts.length > 0) {
    filters.productIds = resolvedProducts.map((p) => p.id)
  }
 
  // Apply any active category/attribute filters
  if (sessionContext.activeFilters.category) {
    filters.category = sessionContext.activeFilters.category
  }
 
  return { query, filters }
}

type BuyingIntent = 'exploring' | 'comparing' | 'specifying' | 'ready-to-order'
 
const INTENT_SIGNALS: Record<BuyingIntent, string[]> = {
  exploring: [
    'what do you have', 'show me', 'what options', 'I need', 'looking for',
  ],
  comparing: [
    'difference between', 'vs', 'compared to', 'which is better', 'pros and cons',
  ],
  specifying: [
    'load capacity', 'dimensions', 'material', 'certification', 'technical spec',
    'how many', 'how much', 'weight', 'rating',
  ],
  'ready-to-order': [
    'add to cart', 'order', 'buy', 'price', 'delivery', 'stock', 'availability',
    'lead time', 'minimum order',
  ],
}
 
function detectIntent(message: string): BuyingIntent | null {
  const lower = message.toLowerCase()
  for (const [intent, signals] of Object.entries(INTENT_SIGNALS)) {
    if (signals.some((s) => lower.includes(s))) {
      return intent as BuyingIntent
    }
  }
  return null
}

class BuyerShortlist {
  private items: Map<string, { product: ProductRef; quantity?: number; note?: string }> = new Map()
 
  add(product: ProductRef, quantity?: number) {
    this.items.set(product.id, { product, quantity })
  }
 
  remove(productId: string) {
    this.items.delete(productId)
  }
 
  updateQuantity(productId: string, quantity: number) {
    const item = this.items.get(productId)
    if (item) item.quantity = quantity
  }
 
  summarize(): string {
    if (this.items.size === 0) return 'No items in shortlist.'
    return Array.from(this.items.values())
      .map((item) => {
        const qty = item.quantity ? ` × ${item.quantity}` : ''
        return `- ${item.product.name} (${item.product.id})${qty}`
      })
      .join('\n')
  }
 
  toOrderPayload() {
    return Array.from(this.items.values()).map(({ product, quantity }) => ({
      productId: product.id,
      quantity: quantity ?? 1,
    }))
  }
}

async function detectAmbiguity(
  query: string,
  sessionContext: SessionContext,
  retrievedChunks: Chunk[]
): Promise<string | null> {
  // Multiple highly-scored products → ambiguous reference
  if (sessionContext.focusedProducts.length > 3) {
    return `I want to make sure I'm answering about the right product. Are you asking about ${
      sessionContext.focusedProducts.slice(0, 3).map((p) => p.name).join(', ')
    }, or a different item?`
  }
 
  // No focused products + pronoun → unclear reference
  const hasVagueTerm = ['it', 'those', 'them', 'that'].some((t) =>
    query.toLowerCase().includes(t)
  )
  if (hasVagueTerm && sessionContext.focusedProducts.length === 0) {
    return `Could you clarify which product you're referring to? I want to make sure I pull the right specifications.`
  }
 
  // Retrieval returned low-confidence chunks
  if (retrievedChunks.every((c) => c.score < 0.6)) {
    return `I don't have detailed information on that specific aspect in my current catalog. Could you give me more detail, or would you like me to flag this for our technical team?`
  }
 
  return null  // No ambiguity detected
}

async function buildPrompt(
  userMessage: string,
  buffer: ConversationBuffer,
  sessionContext: SessionContext,
  retrievedChunks: Chunk[]
): Promise<{ system: string; user: string }> {
  const context = retrievedChunks
    .map((c) => `[${c.source}]\n${c.text}`)
    .join('\n\n---\n\n')
 
  const system = `
You are a B2B product specialist for a wholesale distributor. 
You help buyers find the right products, answer technical questions, and build orders.
 
Current session state:
- Products in focus: ${sessionContext.focusedProducts.map((p) => p.name).join(', ') || 'none'}
- Active requirements: ${JSON.stringify(sessionContext.activeFilters)}
- Buyer stage: ${sessionContext.intent}
- Shortlist: ${sessionContext.shortlist.length} items
 
Be specific, accurate, and use technical language appropriate for B2B buyers.
If you're uncertain, say so. Never invent specifications.
When the buyer seems ready to order, offer to summarize their shortlist and check availability.
`
 
  const user = `
Recent conversation:
${buffer.format()}
 
Product information:
${context}
 
Buyer's latest message: ${userMessage}
`
 
  return { system, user }
}

const testScenario = {
  name: 'Buyer narrows from category to specific SKU',
  turns: [
    { user: 'I need heavy-duty shelf brackets for a warehouse racking system' },
    { user: 'Which of those are rated for over 150kg per bracket?' },
    { user: 'Do the HD-500 come in stainless?' },
    { user: 'How many would I need for a 4-meter shelf?' },
    { user: 'What\'s the minimum order quantity?' },
  ],
  assertions: [
    // Turn 2: "those" resolves to shelf brackets from turn 1
    { turnIndex: 1, check: 'response mentions HD-series or similar heavy-duty brackets' },
    // Turn 3: "HD-500" is now in focus
    { turnIndex: 2, check: 'response addresses stainless steel availability for HD-500' },
    // Turn 4: calculation uses shelf bracket context, not generic
    { turnIndex: 3, check: 'response gives bracket count recommendation for 4 meters' },
    // Turn 5: MOQ is for HD-500, not a generic answer
    { turnIndex: 4, check: 'response gives MOQ specific to HD-500 stainless' },
  ],
}