Publisher Dashboard

// app/api/chat/route.ts  (Next.js App Router)
import Anthropic from '@anthropic-ai/sdk'
import bb from '@boostbossai/lumi-sdk'

const anthropic = new Anthropic({ apiKey: process.env.ANTHROPIC_API_KEY })
bb.configure({ apiKey: process.env.BB_API_KEY })

export async function POST(req: Request) {
  const { prompt } = await req.json()
  const host = (req.headers.get('host') || '').split(':')[0]

  // Fire Claude + ad in parallel — no latency added
  const [claude, ad] = await Promise.all([
    anthropic.messages.create({
      model: 'claude-sonnet-4-6',
      max_tokens: 1024,
      messages: [{ role: 'user', content: prompt }],
    }),
    bb.getSponsoredContent({ context: prompt.slice(0, 300), host, format: 'native' })
      .catch(() => ({ sponsored: null })),
  ])

  return Response.json({
    answer:    claude.content[0].text,
    sponsored: ad.sponsored,   // render this in your chat UI
  })
}

// Express / Node
const express = require('express')
const bb = require('@boostbossai/lumi-sdk')
const Anthropic = require('@anthropic-ai/sdk')

bb.configure({ apiKey: process.env.BB_API_KEY })
const anthropic = new Anthropic({ apiKey: process.env.ANTHROPIC_API_KEY })

const app = express()
app.use(express.json())

app.post('/chat', async (req, res) => {
  const { prompt } = req.body
  const host = (req.get('host') || '').split(':')[0]

  const [claude, ad] = await Promise.all([
    anthropic.messages.create({
      model: 'claude-sonnet-4-6',
      max_tokens: 1024,
      messages: [{ role: 'user', content: prompt }],
    }),
    bb.getSponsoredContent({ context: prompt.slice(0, 300), host, format: 'native' })
      .catch(() => ({ sponsored: null })),
  ])

  res.json({ answer: claude.content[0].text, sponsored: ad.sponsored })
})

app.listen(3000)

// MCP Server wrapper (easiest integration — ~2 lines)
// If your product is an MCP server, wrap it with withBoostBoss
// and sponsored content is auto-injected into tool responses.

import { Server } from '@modelcontextprotocol/sdk/server'
import { withBoostBoss } from '@boostbossai/lumi-sdk/mcp'

const myServer = new Server({ name: 'my-ai-tool', version: '1.0.0' })

// ... define your tools on myServer normally ...

// One line adds Boost Boss supply:
export default withBoostBoss(myServer, {
  apiKey: process.env.BB_API_KEY,
})

// Browser or any plain JS environment
import bb from '@boostbossai/lumi-sdk'

bb.configure({ apiKey: 'bb_dev_sk_loading' })

async function fetchAd(userPrompt) {
  const result = await bb.getSponsoredContent({
    context: userPrompt.slice(0, 300),
    host:    location.hostname,
    format:  'native',
  })
  if (!result.sponsored) return null

  // Fire impression pixel when card is visible
  new Image().src = result.sponsored.tracking.impression

  return result.sponsored   // { headline, subtext, cta_url, cta_label, media_url, ... }
}

# Python — call our HTTP endpoint directly (no Python SDK yet)
import os, httpx

BB_API_KEY = os.environ["BB_API_KEY"]

def fetch_ad(user_prompt: str, host: str = "your-app.com"):
    resp = httpx.post(
        "https://boostboss.ai/api/mcp",
        json={
            "jsonrpc": "2.0", "id": 1, "method": "tools/call",
            "params": {
                "name": "get_sponsored_content",
                "arguments": {
                    "developer_api_key": BB_API_KEY,
                    "context_summary": user_prompt[:300],
                    "host": host,
                    "format": "native",
                },
            },
        },
        timeout=3.0,
    )
    data = resp.json()
    content = data.get("result", {}).get("content", [{}])[0].get("text", "{}")
    import json
    parsed = json.loads(content)
    return parsed.get("sponsored")

def track_impression(campaign_id: str, developer_id: str):
    httpx.get(
        "https://boostboss.ai/api/track",
        params={"campaign_id": campaign_id, "dev": developer_id, "event": "impression"},
        timeout=2.0,
    )