Skip to main content

​
LaminarClient

HTTP client for Laminar API operations.
import { LaminarClient } from '@lmnr-ai/lmnr';

const client = new LaminarClient({
  projectApiKey: process.env.LMNR_PROJECT_API_KEY,
});

// Tag a completed trace
await client.tags.tag(traceId, ['user-feedback-positive']);
Constructor parameters:
NameTypeDefaultDescription
projectApiKeystringLMNR_PROJECT_API_KEY envAPI key
baseUrlstringhttps://api.lmnr.aiAPI base URL
portnumber443API port
Resources:

​
client.tags.tag(traceId, tags)

Add tags to a completed trace.
await client.tags.tag('trace-uuid', ['positive-feedback', 'resolved']);
Example: Capture a trace ID and tag later
import { Laminar, LaminarClient, observe } from '@lmnr-ai/lmnr';

Laminar.initialize();
const client = new LaminarClient();

const traceId = await observe({ name: 'chat_completion' }, async () => {
  // ... your work ...
  return Laminar.getTraceId();
});

await Laminar.flush();

if (traceId) {
  await client.tags.tag(traceId, 'good');
}
Parameters:
NameTypeDefaultDescription
traceIdstring—Trace UUID
tagsstring[] | string—Tag(s) to add
Returns: Promise<any>Note: Call after Laminar.flush() to ensure trace exists.

​
client.traces.pushMetadata(traceId, metadata)

Push a metadata patch to a finished trace. The patch is shallow-merged into the trace’s existing metadata server-side. Use it for post-hoc signals (quality scores, reviewer notes, edit counts) you compute after the trace ends.
import { Laminar, LaminarClient, observe } from '@lmnr-ai/lmnr';

Laminar.initialize();
const client = new LaminarClient();

const traceId = await observe({ name: 'chat_completion' }, async () => {
  // ... your work ...
  return Laminar.getTraceId();
});

await Laminar.flush();

if (traceId) {
  await client.traces.pushMetadata(traceId, {
    score: 0.85,
    reviewer: 'alice',
    editsMade: 2,
  });
}
Parameters:
NameTypeDefaultDescription
traceIdstring—Trace UUID, or a 32-char OTel hex trace id
metadataRecord<string, unknown>—Patch merged into existing trace metadata. Must be non-empty
Returns: Promise<void>Note: Call after Laminar.flush() to ensure the trace exists. If the trace can’t be found at processing time, the call logs a warning and returns without raising. The patch increments the trace’s numSpans by 1 (the virtual span that carried the patch) but does not change endTime, tokens, cost, top span, tags, or span names.

​
client.rolloutSessions

Rollout session management and SSE connections for rollout debugging.
const response = await client.rolloutSessions.connect({
  sessionId: 'session-uuid',
  name: 'generateStream',
  params: [{ name: 'messages', required: true }],
});

​
client.rolloutSessions.connect(options)

Connect to a rollout session and return the SSE streaming response.Parameters:
NameTypeDefaultDescription
options.sessionIdstring—Rollout session UUID
options.namestring—Rollout entrypoint name
options.paramsRolloutParam[]—Entrypoint parameter metadata
options.signalAbortSignal—Abort signal for the request
Returns: Promise<Response>

​
client.rolloutSessions.setStatus(options)

Update the rollout session status.Parameters:
NameTypeDefaultDescription
options.sessionIdstring—Rollout session UUID
options.status'PENDING' | 'RUNNING' | 'FINISHED' | 'STOPPED'—New status
Returns: Promise<void>

​
client.rolloutSessions.sendSpanUpdate(options)

Stream span updates to the rollout session.Parameters:
NameTypeDefaultDescription
options.sessionIdstring—Rollout session UUID
options.spanobject—Span payload (OTel IDs and attributes)
Returns: Promise<void>Span payload:
NameTypeDescription
namestringSpan name
startTimestringISO timestamp
spanIdstringOTel span ID
traceIdstringOTel trace ID
parentSpanIdstring | undefinedParent span ID
attributesRecord<string, any>Span attributes
spanTypeSpanTypeSpan type

​
client.rolloutSessions.delete(options)

Delete a rollout session.Parameters:
NameTypeDefaultDescription
options.sessionIdstring—Rollout session UUID
Returns: Promise<void>

​
client.datasets

Dataset operations.
// List datasets
const datasets = await client.datasets.listDatasets();

// Get by name
const dataset = await client.datasets.getDatasetByName('my-dataset');

// Push datapoints
await client.datasets.push({
  name: 'my-dataset',
  points: [{ data: { query: 'test' }, target: { answer: '42' } }],
  createDataset: true,
});

// Pull datapoints
const points = await client.datasets.pull({
  name: 'my-dataset',
  limit: 100,
});

​
client.datasets.listDatasets()

Returns: Promise<Dataset[]>

​
client.datasets.getDatasetByName(name)

Parameters:
NameTypeDefaultDescription
namestring—Dataset name
Returns: Promise<Dataset[]>

​
client.datasets.pull(options)

Pull datapoints from a dataset.Parameters:
NameTypeDefaultDescription
options.namestring—Dataset name
options.idstring—Dataset ID
options.limitnumber100Max datapoints
options.offsetnumber0Pagination offset
Returns: Promise<GetDatapointsResponse<D, T>>

​
client.datasets.push(options)

Push datapoints to a dataset.Parameters:
NameTypeDefaultDescription
options.pointsDatapoint<D, T>[]—Datapoints to push
options.namestring—Dataset name
options.idstring—Dataset ID
options.batchSizenumber100Batch size
options.createDatasetbooleanfalseCreate dataset if missing
Returns: Promise<PushDatapointsResponse | undefined>

​
client.evals

Evaluation operations.
// Initialize evaluation
const eval = await client.evals.init('my-eval', 'default-group');

// Create datapoint
await client.evals.createDatapoint({
  evalId: eval.id,
  data: { query: 'test' },
  target: { answer: '42' },
});

​
client.evals.init(name?, groupName?, metadata?)

Parameters:
NameTypeDefaultDescription
namestring—Evaluation name
groupNamestring—Group name
metadataRecord<string, any>—Evaluation metadata
Returns: Promise<InitEvaluationResponse>

​
client.evals.createDatapoint(options)

Parameters:
NameTypeDefaultDescription
options.evalIdstring—Evaluation UUID
options.dataany—Input data
options.targetany—Target/expected output
options.metadataRecord<string, any>—Datapoint metadata
options.indexnumber—Dataset index
options.traceIdstring—Trace UUID
Returns: Promise<string>

​
client.evaluators.score(options)

Attach evaluator score to a trace or span.
await client.evaluators.score({
  name: 'quality',
  score: 0.95,
  traceId: 'trace-uuid',
});
Parameters:Pass exactly one of traceId or spanId.
NameTypeDefaultDescription
options.namestring—Evaluator name
options.scorenumber—Score value
options.metadataRecord<string, any>—Score metadata
options.traceIdstring—Trace UUID
options.spanIdstring—Span UUID
Returns: Promise<void>

​
client.agent.run(options)

Run a browser agent.
const result = await client.agent.run({
  prompt: 'Find the pricing on example.com',
  maxSteps: 50,
  returnScreenshots: true,
});
Parameters:
NameTypeDefaultDescription
promptstring—Agent instruction (required)
parentSpanContextstringCurrent spanParent trace context
modelstring—Model to use
streambooleanfalseStream responses
maxStepsnumber100Maximum steps
startUrlstring—Starting URL
timeoutnumber—Timeout in ms
returnScreenshotsbooleanfalseInclude screenshots
returnAgentStatebooleanfalseReturn agent state
returnStorageStatebooleanfalseReturn storage state
disableGiveControlbooleanfalseDisable “give control”
enableThinkingbooleantrueEnable thinking
Returns:
  • Promise<AgentOutput> when stream is false
  • Promise<ReadableStream<RunAgentResponseChunk>> when stream is true