@lmnr-ai/client 0.8.1

package/dist/index.d.mts

@@ -0,0 +1,381 @@
+import { Datapoint, Dataset, EvaluationDatapoint, GetDatapointsResponse, InitEvaluationResponse, PushDatapointsResponse, RolloutParam, SpanType, StringUUID } from "@lmnr-ai/types";
+
+//#region src/resources/index.d.ts
+declare class BaseResource {
+  protected readonly baseHttpUrl: string;
+  protected readonly projectApiKey: string;
+  constructor(baseHttpUrl: string, projectApiKey: string);
+  protected headers(): {
+    Authorization: string;
+    "Content-Type": string;
+    Accept: string;
+  };
+  protected handleError(response: Response): Promise<void>;
+}
+//#endregion
+//#region src/resources/browser-events.d.ts
+declare class BrowserEventsResource extends BaseResource {
+  constructor(baseHttpUrl: string, projectApiKey: string);
+  send({
+    sessionId,
+    traceId,
+    events
+  }: {
+    sessionId: string;
+    traceId: string;
+    events: Record<string, any>[];
+  }): Promise<void>;
+}
+//#endregion
+//#region src/resources/datasets.d.ts
+declare class DatasetsResource extends BaseResource {
+  constructor(baseHttpUrl: string, projectApiKey: string);
+  /**
+   * List all datasets.
+   *
+   * @returns {Promise<Dataset[]>} Array of datasets
+   */
+  listDatasets(): Promise<Dataset[]>;
+  /**
+   * Get a dataset by name.
+   *
+   * @param {string} name - Name of the dataset
+   * @returns {Promise<Dataset[]>} Array of datasets with matching name
+   */
+  getDatasetByName(name: string): Promise<Dataset[]>;
+  /**
+   * Push datapoints to a dataset.
+   *
+   * @param {Object} options - Push options
+   * @param {Datapoint<D, T>[]} options.points - Datapoints to push
+   * @param {string} [options.name] - Name of the dataset (either name or id must be provided)
+   * @param {StringUUID} [options.id] - ID of the dataset (either name or id must be provided)
+   * @param {number} [options.batchSize] - Batch size for pushing (default: 100)
+   * @param {boolean} [options.createDataset] - Whether to create the dataset if it doesn't exist
+   * @returns {Promise<PushDatapointsResponse | undefined>}
+   */
+  push<D, T>({
+    points,
+    name,
+    id,
+    batchSize,
+    createDataset
+  }: {
+    points: Datapoint<D, T>[];
+    name?: string;
+    id?: StringUUID;
+    batchSize?: number;
+    createDataset?: boolean;
+  }): Promise<PushDatapointsResponse | undefined>;
+  /**
+   * Pull datapoints from a dataset.
+   *
+   * @param {Object} options - Pull options
+   * @param {string} [options.name] - Name of the dataset (either name or id must be provided)
+   * @param {StringUUID} [options.id] - ID of the dataset (either name or id must be provided)
+   * @param {number} [options.limit] - Maximum number of datapoints to return (default: 100)
+   * @param {number} [options.offset] - Offset for pagination (default: 0)
+   * @returns {Promise<GetDatapointsResponse<D, T>>}
+   */
+  pull<D, T>({
+    name,
+    id,
+    limit,
+    offset
+  }: {
+    name?: string;
+    id?: StringUUID;
+    limit?: number;
+    offset?: number;
+  }): Promise<GetDatapointsResponse<D, T>>;
+}
+//#endregion
+//#region src/resources/evals.d.ts
+declare class EvalsResource extends BaseResource {
+  constructor(baseHttpUrl: string, projectApiKey: string);
+  /**
+   * Initialize an evaluation.
+   *
+   * @param {string} name - Name of the evaluation
+   * @param {string} groupName - Group name of the evaluation
+   * @param {Record<string, any>} metadata - Optional metadata
+   * @returns {Promise<InitEvaluationResponse>} Response from the evaluation initialization
+   */
+  init(name?: string, groupName?: string, metadata?: Record<string, any>): Promise<InitEvaluationResponse>;
+  /**
+   * Create a new evaluation and return its ID.
+   *
+   * @param {string} [name] - Optional name of the evaluation
+   * @param {string} [groupName] - An identifier to group evaluations
+   * @param {Record<string, any>} [metadata] - Optional metadata
+   * @returns {Promise<StringUUID>} The evaluation ID
+   */
+  create(args?: {
+    name?: string;
+    groupName?: string;
+    metadata?: Record<string, any>;
+  }): Promise<StringUUID>;
+  /**
+   * Create a new evaluation and return its ID.
+   * @deprecated use `create` instead.
+   */
+  createEvaluation(name?: string, groupName?: string, metadata?: Record<string, any>): Promise<StringUUID>;
+  /**
+   * Create a datapoint for an evaluation.
+   *
+   * @param {Object} options - Create datapoint options
+   * @param {string} options.evalId - The evaluation ID
+   * @param {D} options.data - The input data for the executor
+   * @param {T} [options.target] - The target/expected output for evaluators
+   * @param {Record<string, any>} [options.metadata] - Optional metadata
+   * @param {number} [options.index] - Optional index of the datapoint
+   * @param {string} [options.traceId] - Optional trace ID
+   * @returns {Promise<StringUUID>} The datapoint ID
+   */
+  createDatapoint<D, T>({
+    evalId,
+    data,
+    target,
+    metadata,
+    index,
+    traceId
+  }: {
+    evalId: string;
+    data: D;
+    target?: T;
+    metadata?: Record<string, any>;
+    index?: number;
+    traceId?: string;
+  }): Promise<StringUUID>;
+  /**
+   * Update a datapoint with evaluation results.
+   *
+   * @param {Object} options - Update datapoint options
+   * @param {string} options.evalId - The evaluation ID
+   * @param {string} options.datapointId - The datapoint ID
+   * @param {Record<string, number>} options.scores - The scores
+   * @param {O} [options.executorOutput] - The executor output
+   * @returns {Promise<void>}
+   */
+  updateDatapoint<O>({
+    evalId,
+    datapointId,
+    scores,
+    executorOutput
+  }: {
+    evalId: string;
+    datapointId: string;
+    scores: Record<string, number>;
+    executorOutput?: O;
+  }): Promise<void>;
+  /**
+   * Save evaluation datapoints.
+   *
+   * @param {Object} options - Save datapoints options
+   * @param {string} options.evalId - ID of the evaluation
+   * @param {EvaluationDatapoint<D, T, O>[]} options.datapoints - Datapoint to add
+   * @param {string} [options.groupName] - Group name of the evaluation
+   * @returns {Promise<void>} Response from the datapoint addition
+   */
+  saveDatapoints<D, T, O>({
+    evalId,
+    datapoints,
+    groupName
+  }: {
+    evalId: string;
+    datapoints: EvaluationDatapoint<D, T, O>[];
+    groupName?: string;
+  }): Promise<void>;
+  /**
+   * Get evaluation datapoints.
+   *
+   * @deprecated Use `client.datasets.pull()` instead.
+   * @param {Object} options - Get datapoints options
+   * @param {string} options.datasetName - Name of the dataset
+   * @param {number} options.offset - Offset at which to start the query
+   * @param {number} options.limit - Maximum number of datapoints to return
+   * @returns {Promise<GetDatapointsResponse>} Response from the datapoint retrieval
+   */
+  getDatapoints<D, T>({
+    datasetName,
+    offset,
+    limit
+  }: {
+    datasetName: string;
+    offset: number;
+    limit: number;
+  }): Promise<GetDatapointsResponse<D, T>>;
+  private retrySaveDatapoints;
+}
+//#endregion
+//#region src/resources/evaluators.d.ts
+type ScoreOptions = {
+  name: string;
+  metadata?: Record<string, any>;
+  score: number;
+  traceId: string;
+} | {
+  name: string;
+  metadata?: Record<string, any>;
+  score: number;
+  spanId: string;
+};
+/**
+ * Resource for creating evaluator scores
+ */
+declare class EvaluatorsResource extends BaseResource {
+  constructor(baseHttpUrl: string, projectApiKey: string);
+  /**
+   * Create a score for a span or trace
+   *
+   * @param {ScoreOptions} options - Score creation options
+   * @param {string} options.name - Name of the score
+   * @param {string} [options.traceId] - The trace ID to score (will be attached to top-level span)
+   * @param {string} [options.spanId] - The span ID to score
+   * @param {Record<string, any>} [options.metadata] - Additional metadata
+   * @param {number} options.score - The score value (float)
+   * @returns {Promise<void>}
+   *
+   * @example
+   * // Score by trace ID (will attach to root span)
+   * await evaluators.score({
+   *   name: "quality",
+   *   traceId: "trace-id-here",
+   *   score: 0.95,
+   *   metadata: { model: "gpt-4" }
+   * });
+   *
+   * @example
+   * // Score by span ID
+   * await evaluators.score({
+   *   name: "relevance",
+   *   spanId: "span-id-here",
+   *   score: 0.87
+   * });
+   */
+  score(options: ScoreOptions): Promise<void>;
+}
+//#endregion
+//#region src/resources/rollout-sessions.d.ts
+declare class RolloutSessionsResource extends BaseResource {
+  constructor(baseHttpUrl: string, projectApiKey: string);
+  /**
+   * Connects to the SSE stream for rollout debugging sessions
+   * Returns the Response object for streaming SSE events
+   */
+  connect({
+    sessionId,
+    name,
+    params,
+    signal
+  }: {
+    sessionId: string;
+    params: RolloutParam[];
+    name: string;
+    signal?: AbortSignal;
+  }): Promise<Response>;
+  delete({
+    sessionId
+  }: {
+    sessionId: string;
+  }): Promise<void>;
+  setStatus({
+    sessionId,
+    status
+  }: {
+    sessionId: string;
+    status: 'PENDING' | 'RUNNING' | 'FINISHED' | 'STOPPED';
+  }): Promise<void>;
+  sendSpanUpdate({
+    sessionId,
+    span
+  }: {
+    sessionId: string;
+    span: {
+      name: string;
+      startTime: string;
+      spanId: string;
+      traceId: string;
+      parentSpanId: string | undefined;
+      attributes: Record<string, any>;
+      spanType: SpanType;
+    };
+  }): Promise<void>;
+}
+//#endregion
+//#region src/resources/sql.d.ts
+declare class SqlResource extends BaseResource {
+  constructor(baseHttpUrl: string, projectApiKey: string);
+  query(sql: string, parameters?: Record<string, any>): Promise<Array<Record<string, any>>>;
+}
+//#endregion
+//#region src/resources/tags.d.ts
+declare class TagsResource extends BaseResource {
+  /** Resource for tagging traces. */
+  constructor(baseHttpUrl: string, projectApiKey: string);
+  /**
+   * Tag a trace with a list of tags. Note that the trace must be ended before
+   * tagging it. You may want to call `await Laminar.flush()` after the trace
+   * that you want to tag.
+   *
+   * @param {string | StringUUID} trace_id - The trace id to tag.
+   * @param {string[] | string} tags - The tag or list of tags to add to the trace.
+   * @returns {Promise<any>} The response from the server.
+   * @example
+   * ```javascript
+   * import { Laminar, observe, LaminarClient } from "@lmnr-ai/lmnr";
+   * Laminar.initialize();
+   * const client = new LaminarClient();
+   * let traceId: StringUUID | null = null;
+   * // Make sure this is called outside of traced context.
+   * await observe(
+   *   {
+   *     name: "my-trace",
+   *   },
+   *   async () => {
+   *     traceId = await Laminar.getTraceId();
+   *     await foo();
+   *   },
+   * );
+   *
+   * // or make sure the trace is ended by this point.
+   * await Laminar.flush();
+   * if (traceId) {
+   *   await client.tags.tag(traceId, ["tag1", "tag2"]);
+   * }
+   * ```
+   */
+  tag(trace_id: string, tags: string[] | string): Promise<any>;
+}
+//#endregion
+//#region src/index.d.ts
+declare class LaminarClient {
+  private baseUrl;
+  private projectApiKey;
+  private _browserEvents;
+  private _datasets;
+  private _evals;
+  private _evaluators;
+  private _rolloutSessions;
+  private _sql;
+  private _tags;
+  constructor({
+    baseUrl,
+    projectApiKey,
+    port
+  }?: {
+    baseUrl?: string;
+    projectApiKey?: string;
+    port?: number;
+  });
+  get browserEvents(): BrowserEventsResource;
+  get datasets(): DatasetsResource;
+  get evals(): EvalsResource;
+  get evaluators(): EvaluatorsResource;
+  get rolloutSessions(): RolloutSessionsResource;
+  get sql(): SqlResource;
+  get tags(): TagsResource;
+}
+//#endregion
+export { LaminarClient };
+//# sourceMappingURL=index.d.mts.map