How to log OpenAI API calls with tokens and cost

import { Mcpd } from '@mcpd/sdk'
import OpenAI from 'openai'

// Reads MCPD_ENDPOINT and MCPD_API_KEY. With neither set it talks to
// http://localhost:4317 with no key.
const mcpd = new Mcpd({ project: 'support', serviceName: 'support-api' })
const openai = new OpenAI()

from mcpd import Mcpd, SpanKind
from openai import OpenAI

# Reads MCPD_ENDPOINT and MCPD_API_KEY. With neither set it talks to
# http://localhost:4317 with no key.
mcpd = Mcpd(project="support", service_name="support-api")
client = OpenAI()

async function answer(question: string, userId: string): Promise<string> {
  return await mcpd.withSpan('answer_question', async (run) => {
    run.setCorrelation({ userId })
    run.setInput({ question })
    const messages = [
      { role: 'system' as const, content: 'You answer questions about orders.' },
      { role: 'user' as const, content: question },
    ]
    const text = await mcpd.withSpan(
      'chat',
      async (generation) => {
        generation.setInput(messages)
        generation.setModelParameters({ temperature: 0.2, maxTokens: 300 })
        const response = await openai.chat.completions.create({
          model: 'gpt-4.1-mini',
          messages,
          temperature: 0.2,
          max_tokens: 300,
        })
        // Model, provider, token counts, response id and finish reason.
        generation.recordResponse(response)
        const text = response.choices[0]?.message.content ?? ''
        generation.setOutput(text)
        return text
      },
      { kind: 'model_generation' },
    )
    run.setOutput({ answer: text })
    return text
  })
}

def answer(question: str, user_id: str) -> str:
    with mcpd.trace("answer_question", user_id=user_id) as run:
        run.set_input({"question": question})
        messages = [
            {"role": "system", "content": "You answer questions about orders."},
            {"role": "user", "content": question},
        ]
        with mcpd.span("chat", kind=SpanKind.MODEL_GENERATION) as generation:
            generation.set_input(messages)
            generation.set_model_parameters(temperature=0.2, max_tokens=300)
            response = client.chat.completions.create(
                model="gpt-4.1-mini",
                messages=messages,
                temperature=0.2,
                max_tokens=300,
            )
            # Model, provider, token counts, response id and finish reason.
            generation.record_response(response)
            text = response.choices[0].message.content
            generation.set_output(text)
        run.set_output({"answer": text})
        return text

async function streamAnswer(question: string): Promise<string> {
  return await mcpd.withSpan(
    'chat',
    async (generation) => {
      const messages = [{ role: 'user' as const, content: question }]
      generation.setInput(messages)
      const stream = await openai.chat.completions.create({
        model: 'gpt-4.1-mini',
        messages,
        stream: true,
        // Without this, OpenAI sends no token counts on a stream.
        stream_options: { include_usage: true },
      })
      let text = ''
      for await (const chunk of generation.recordStream(stream)) {
        text += chunk.choices[0]?.delta.content ?? ''
      }
      return text
    },
    { kind: 'model_generation' },
  )
}

def stream_answer(question: str) -> str:
    with mcpd.span("chat", kind=SpanKind.MODEL_GENERATION) as generation:
        messages = [{"role": "user", "content": question}]
        generation.set_input(messages)
        stream = client.chat.completions.create(
            model="gpt-4.1-mini",
            messages=messages,
            stream=True,
            # Without this, OpenAI sends no token counts on a stream.
            stream_options={"include_usage": True},
        )
        text = ""
        for chunk in generation.record_stream(stream):
            if chunk.choices:
                text += chunk.choices[0].delta.content or ""
        return text

console.log(await answer('Where is order 4417?', 'customer-7'))
console.log(await streamAnswer('Where is order 4417?'))
// Sends what is still queued. A server that keeps running does not need it.
await mcpd.shutdown()

print(answer("Where is order 4417?", "customer-7"))
print(stream_answer("Where is order 4417?"))
# Sends what is still queued. A server that keeps running does not need it.
mcpd.shutdown()

# The newest run named answer_question.
TRACE=$(curl -s "http://localhost:4317/v1/api/traces?project=support&name=answer_question&limit=1" \
  | jq -r '.traces[0].trace_id')

# Every step of it, with the model, the tokens and the cost.
curl -s "http://localhost:4317/v1/api/traces/$TRACE?project=support" \
  | jq -c '.spans[] | {name, kind, model, usage, cost: .cost.total_cost}'