import { AISDK } from '@browserstack/ai-sdk';

const testOps = new AISDK({
  publicKey: process.env.AISDK_PUBLIC_KEY,
  secretKey: process.env.AISDK_SECRET_KEY,
});

const trace = testOps.trace({
  name: 'qa-pipeline',
  userId: 'user-123',
  sessionId: 'session-456',
  input: { question: 'What is the capital of France?' },
  metadata: { source: 'api' },
  tags: ['production', 'v2'],
});

import os
from browserstack_ai_sdk import AISDK

client = AISDK(
    public_key=os.environ["AISDK_PUBLIC_KEY"],
    secret_key=os.environ["AISDK_SECRET_KEY"],
)

trace = client.trace(
    name="rag-pipeline",
    user_id="user-123",
    session_id="session-abc",
    tags=["rag", "production"],
    metadata={"version": "2.0"},
)

import com.browserstack.aisdk.AISDK;
import com.browserstack.aisdk.tracing.TraceManager;
import com.browserstack.aisdk.tracing.model.TraceBody;

AISDK sdk = AISDK.fromEnv();
TraceManager tm = sdk.traceManager();

var trace = tm.trace(TraceBody.builder()
    .name("answer-question")
    .input("What causes Northern Lights?")
    .userId("user-42")
    .sessionId("session-abc")
    .environment("production")
    .build());

import { AISDK } from '@browserstack/ai-sdk';

const testOps = new AISDK({
  publicKey: process.env.AISDK_PUBLIC_KEY,
  secretKey: process.env.AISDK_SECRET_KEY,
});

// Option 1 — pass the custom string directly
const trace = testOps.trace({
  id: 'request-abc-123',
  name: 'qa-pipeline',
});

console.log(trace.id);        // 32-char hex (deterministic for 'request-abc-123')
console.log(trace.customId);  // 'request-abc-123'

// Option 2 — pre-compute when you need the hex up front
const traceId = testOps.generateTraceId('request-abc-123');
const sameTrace = testOps.trace({ id: traceId, name: 'qa-pipeline' });
// sameTrace.id === trace.id

import os
from browserstack_ai_sdk import AISDK

client = AISDK(
    public_key=os.environ["AISDK_PUBLIC_KEY"],
    secret_key=os.environ["AISDK_SECRET_KEY"],
)

# Option 1 — pass the custom string directly
trace = client.trace(id="request-abc-123", name="qa-pipeline")

print(trace.id)         # 32-char hex (deterministic for 'request-abc-123')
print(trace.custom_id)  # 'request-abc-123'

# Option 2 — pre-compute when you need the hex up front
trace_id = client.generate_trace_id("request-abc-123")
same_trace = client.trace(id=trace_id, name="qa-pipeline")
# same_trace.id == trace.id

import com.browserstack.aisdk.AISDK;
import com.browserstack.aisdk.tracing.model.TraceBody;

AISDK sdk = AISDK.fromEnv();

// Pass the custom string directly as `id`
TraceBody body = TraceBody.builder()
    .id("request-abc-123")
    .name("qa-pipeline")
    .build();

var trace = sdk.tracing().trace(body);
System.out.println(trace.getId());

const trace = testOps.trace({ name: 'qa-pipeline', input: { q: 'Hello?' } });

// ... run your pipeline ...

trace.update({
  output: 'Paris is the capital of France.',
  metadata: { latencyMs: 320 },
});

trace = client.trace(name="qa-pipeline", input={"question": "What is the capital of France?"})

# ... run your pipeline ...

trace.update(output="Paris is the capital of France.")

trace.update(TraceBody.builder()
    .output("The Aurora Borealis is caused by solar wind particles...")
    .build());

const trace = testOps.trace({ name: 'rag-pipeline' });

const retrievalSpan = trace.span({
  name: 'vector-search',
  input: { query: 'capital of France', topK: 5 },
});

const vectorStore = {
  search: async (query, { topK }) => [
    { id: 'doc1', text: 'Paris is the capital of France.', score: 0.92 },
    { id: 'doc2', text: 'France is a country in Europe.', score: 0.81 },
  ],
};

const docs = await vectorStore.search('capital of France', { topK: 5 });

retrievalSpan.end({
  output: docs,
  metadata: { source: 'pinecone' },
});

retrieval_span = trace.span(
    name="retrieve-documents",
    input={"query": "What is the capital of France?"},
)

documents = ["France is a country in Western Europe. Its capital is Paris."]

retrieval_span.update(output={"documents": documents})
retrieval_span.end()

import com.browserstack.aisdk.tracing.model.SpanBody;

long start = System.currentTimeMillis();

List<String> docs = vectorDb.search(query);

var retrieval = trace.span(SpanBody.builder()
    .name("vector-retrieval")
    .input(query)
    .output(docs)
    .startTime(start)
    .endTime(System.currentTimeMillis())
    .metadata(Map.of("collection", "knowledge-base", "topK", 5))
    .build());

var span = trace.span(SpanBody.builder().name("processing").build());
// ... do work ...
span.end(); // records endTime = now

const trace = testOps.trace({ name: 'agent-run' });

trace.event({
  name: 'tool-selected',
  input: { toolName: 'search_web' },
  metadata: { reasoning: 'User asked for current info' },
});

span = trace.start_span(name="agent-step")
span.create_event(
    name="cache-miss",
    input={"key": "query-123"},
)
span.end()

import com.browserstack.aisdk.tracing.model.EventBody;

trace.event(EventBody.builder()
    .name("cache-miss")
    .input(Map.of("key", query))
    .metadata(Map.of("reason", "ttl-expired"))
    .build());

// Score on a trace
testOps.score({
  traceId: trace.id,
  name: 'relevance',
  value: 0.92,
  comment: 'Answer was highly relevant to the question.',
});

// Score on a specific generation
testOps.score({
  traceId: trace.id,
  observationId: generation.id,
  name: 'faithfulness',
  value: 1.0,
});

trace.score(
    name="correctness",
    value=1.0,
    comment="Answer is correct",
)

import com.browserstack.aisdk.tracing.model.ScoreBody;

// Score a generation
gen.score(ScoreBody.builder()
    .name("faithfulness")
    .value(0.92)
    .comment("Answer stays within the provided context.")
    .build());

// Score a trace
trace.score(ScoreBody.builder()
    .name("overall-quality")
    .value(0.85)
    .dataType("NUMERIC")
    .build());

const trace = testOps.trace({ name: 'agent' });

const agentSpan = trace.span({ name: 'agent-step-1' });

// Nest a generation inside a span
const generation = agentSpan.generation({
  name: 'tool-decision',
  model: 'gpt-4o',
  input: [{ role: 'user', content: 'Which tool should I use?' }],
});

generation.end({ output: 'search_web' });
agentSpan.end({});

trace = client.trace(name="agent")

span = trace.start_span(
    name="agent-step-1",
    input={"query": "hello"},
)

gen = span.start_generation(
    name="llm-call",
    model="gpt-4o",
    input="Say hello in French",
)

gen.update(output="Bonjour!")
gen.end()
span.update(output="Bonjour!")
span.end()
client.flush()

String result = tm.withWorkflow("answer-question", () -> {
    // All tracing here is nested under the auto-created trace
    return generateAnswer(question);
});

import { AISDK } from '@browserstack/ai-sdk';

const client = new AISDK({
  publicKey: process.env.AISDK_PUBLIC_KEY,
  secretKey: process.env.AISDK_SECRET_KEY,
});

// 1) Top-level observations — the SDK creates the enclosing trace for you
const span = client.span({ name: 'retrieve-documents', input: { query: 'capital of France' } });
span.end({ output: { documents: ['Paris is the capital of France.'] } });

const generation = client.generation({
  name: 'generate-answer',
  model: 'gpt-4o',
  input: [{ role: 'user', content: 'What is the capital of France?' }],
});
generation.end({ output: 'Paris.', usage: { input: 12, output: 3 } });

client.event({ name: 'cache-miss', input: { key: 'q-123' } }); // instantaneous — no end()

// 2) Nest child observations by chaining off a parent handle
const pipeline = client.span({ name: 'pipeline' });
const rerank = pipeline.span({ name: 'rerank', input: { k: 5 } });
rerank.end();
pipeline.end();

// 3) Attach observations to a specific / shared trace id (e.g. one propagated
//    from another service). Supplying `traceId` attaches to an EXISTING trace,
//    so create it first — in a real distributed flow the upstream service does this.
const traceId = client.generateTraceId('order-1234');
client.trace({ id: traceId, name: 'order-1234' });

client.span({ name: 'service-a-step', traceId }).end();
client.generation({ name: 'service-b-step', model: 'gpt-4o', traceId }).end({ output: 'done' });

await client.shutdown(); // flush before the process exits

import os
from browserstack_ai_sdk import AISDK

client = AISDK(
    public_key=os.environ["AISDK_PUBLIC_KEY"],
    secret_key=os.environ["AISDK_SECRET_KEY"],
)

# 1) Top-level observations — the SDK creates the enclosing trace for you
span = client.start_span(name="retrieve-documents", input={"query": "capital of France"})
span.update(output={"documents": ["Paris is the capital of France."]})
span.end()

generation = client.start_generation(
    name="generate-answer",
    model="gpt-4o",
    input=[{"role": "user", "content": "What is the capital of France?"}],
    expected_output="Paris",                       # evaluation hook (reference answer)
    context=["Paris is the capital of France."],   # evaluation hook (grounding content)
)
generation.update(output="Paris.", usage_details={"input": 12, "output": 3})
generation.end()

client.create_event(name="cache-miss", input={"key": "q-123"})  # instantaneous — already ended

# 2) Nest child observations by passing the parent handle
pipeline = client.start_span(name="pipeline")
rerank = client.start_span(name="rerank", parent_span=pipeline, input={"k": 5})
rerank.end()
pipeline.end()

# 3) Attach observations to a specific / shared trace id (e.g. one propagated
#    from another service). trace_context attaches to an EXISTING trace, so
#    create it first — in a real distributed flow the upstream service does this.
trace_id = client.generate_trace_id("order-12345")
client.trace(id=trace_id, name="order-12345")

a = client.start_span(name="service-a-step", trace_context={"trace_id": trace_id})
a.end()
b = client.start_generation(name="service-b-step", model="gpt-4o",
                            trace_context={"trace_id": trace_id})
b.update(output="done")
b.end()

client.flush()