feat: extend coverage of API

integration-test/langfuse-integration-datasets.spec.ts

@@ -1,4 +1,5 @@
 // uses the compiled node.js version, run yarn build after making changes to the SDKs
+import { utils } from "../langfuse-core/src";
 import Langfuse from "../langfuse-node";
 
 describe("Langfuse Node.js", () => {
@@ -324,4 +325,73 @@ describe("Langfuse Node.js", () => {
       });
     }, 10000);
   });
+  it("create and fetch dataset items", async () => {
+    const datasetName = utils.generateUUID();
+    langfuse.createDataset({
+      name: datasetName,
+      description: "My first dataset",
+      metadata: {
+        author: "Alice",
+        date: "2022-01-01",
+        type: "benchmark",
+      },
+    });
+    langfuse.createDatasetItem({
+      datasetName: datasetName,
+      input: {
+        text: "hello world",
+      },
+      expectedOutput: {
+        text: "hello world",
+      },
+      metadata: {
+        model: "llama3",
+      },
+    });
+    langfuse.createDatasetItem({
+      datasetName: datasetName,
+      input: {
+        text: "goodbye world",
+      },
+      expectedOutput: {
+        text: "goodbye world",
+      },
+      metadata: {
+        model: "llama4",
+      },
+    });
+
+    await langfuse.flushAsync();
+
+    const datasetItems = await langfuse.getDatasetItems({ datasetName: datasetName });
+
+    expect(datasetItems.meta["totalItems"]).toEqual(2);
+    expect(datasetItems.data[0]).toMatchObject({ datasetName: datasetName });
+    expect(datasetItems.data[1]).toMatchObject({ datasetName: datasetName });
+  });
+
+  it("create and fetch datasets", async () => {
+    const datasetName1 = utils.generateUUID();
+    const datasetName2 = utils.generateUUID();
+    const datasetName3 = utils.generateUUID();
+
+    // Create multiple datasets
+    langfuse.createDataset({
+      name: datasetName1,
+      description: "My first dataset",
+    });
+    langfuse.createDataset({
+      name: datasetName2,
+      description: "My second dataset",
+    });
+    langfuse.createDataset({
+      name: datasetName3,
+      description: "My third dataset",
+    });
+
+    const datasets = await langfuse.getDatasets();
+    expect(datasets.data).toContainEqual(expect.objectContaining({ name: datasetName1 }));
+    expect(datasets.data).toContainEqual(expect.objectContaining({ name: datasetName2 }));
+    expect(datasets.data).toContainEqual(expect.objectContaining({ name: datasetName3 }));
+  });
 });

integration-test/langfuse-integration-node.spec.ts

@@ -5,6 +5,7 @@ import Langfuse from "../langfuse-node";
 import axios from "axios";
 import { LANGFUSE_BASEURL, getHeaders } from "./integration-utils";
 import { utils } from "../langfuse-core/src";
+import exp from "constants";
 
 describe("Langfuse Node.js", () => {
   let langfuse: Langfuse;
@@ -551,6 +552,71 @@ describe("Langfuse Node.js", () => {
     });
   });
 
+  it("create and fetch scores", async () => {
+    const traceName = utils.generateUUID();
+    const trace = langfuse.trace({
+      name: traceName,
+    });
+    const score = trace.score({
+      name: "quality",
+      value: 1,
+      comment: "Factually correct",
+    });
+    await langfuse.flushAsync();
+
+    const scores = await langfuse.fetchScores({ name: "quality" });
+    expect(scores.data).toContainEqual(expect.objectContaining({ traceId: score.id, name: "quality" }));
+  });
+
+  it("create and fetch score by id", async () => {
+    const traceName = utils.generateUUID();
+    const trace = langfuse.trace({
+      name: traceName,
+    });
+    trace.score({
+      name: "harmfulness",
+      value: 0.5,
+    });
+    trace.score({
+      name: "quality",
+      value: 1,
+      comment: "Factually correct",
+    });
+    trace.score({
+      name: "relevance",
+      value: 0.8,
+      comment: "Mostly relevant",
+    });
+
+    await langfuse.flushAsync();
+    const scores = await langfuse.fetchScores();
+    const score1 = scores.data[2];
+    const score2 = scores.data[1];
+    const score3 = scores.data[0];
+    const fetchedScore1 = await langfuse.fetchScore(score1.id);
+    expect(fetchedScore1.data).toMatchObject(
+      expect.objectContaining({ traceId: trace.id, name: "harmfulness", value: 0.5 })
+    );
+    const fetchedScore2 = await langfuse.fetchScore(score2.id);
+    expect(fetchedScore2.data).toMatchObject(
+      expect.objectContaining({
+        traceId: trace.id,
+        name: "quality",
+        value: 1,
+        comment: "Factually correct",
+      })
+    );
+    const fetchedScore3 = await langfuse.fetchScore(score3.id);
+    expect(fetchedScore3.data).toMatchObject(
+      expect.objectContaining({
+        traceId: trace.id,
+        name: "relevance",
+        value: 0.8,
+        comment: "Mostly relevant",
+      })
+    );
+  });
+
   it("create 3 traces with different timestamps and fetch the middle one using to and from timestamp", async () => {
     const traceName = utils.generateUUID();
     const traceParams = [
@@ -627,4 +693,48 @@ describe("Langfuse Node.js", () => {
     const sessions = await langfuse.fetchSessions();
     expect(sessions.data).toContainEqual(expect.objectContaining({ id: sessionId }));
   });
+
+  it("create and fetch prompts", async () => {
+    const promptName1 = utils.generateUUID();
+    const promptName2 = utils.generateUUID();
+    const promptName3 = utils.generateUUID();
+
+    // Create multiple prompts
+    await langfuse.createPrompt({
+      name: promptName1,
+      prompt: "This is prompt 1",
+    });
+    await langfuse.createPrompt({
+      name: promptName2,
+      prompt: "This is prompt 2",
+    });
+    await langfuse.createPrompt({
+      name: promptName3,
+      prompt: "This is prompt 3",
+    });
+
+    // Create multiple versions of the same prompt
+    await langfuse.createPrompt({
+      name: promptName1,
+      prompt: "This is prompt 1 version 2",
+    });
+    await langfuse.createPrompt({
+      name: promptName1,
+      prompt: "This is prompt 1 version 3",
+    });
+
+    const prompts = await langfuse.fetchPrompts();
+    expect(prompts.data).toContainEqual(expect.objectContaining({ name: promptName1 }));
+    expect(prompts.data).toContainEqual(expect.objectContaining({ name: promptName2 }));
+    expect(prompts.data).toContainEqual(expect.objectContaining({ name: promptName3 }));
+
+    // Fetch specific versions of the prompt
+    const prompt1Version1 = await langfuse.getPrompt(promptName1, 1);
+    const prompt1Version2 = await langfuse.getPrompt(promptName1, 2);
+    const prompt1Version3 = await langfuse.getPrompt(promptName1, 3);
+
+    expect(prompt1Version1.prompt).toEqual("This is prompt 1");
+    expect(prompt1Version2.prompt).toEqual("This is prompt 1 version 2");
+    expect(prompt1Version3.prompt).toEqual("This is prompt 1 version 3");
+  });
 });

langfuse-core/src/index.ts

@@ -45,6 +45,13 @@ import {
   type ChatMessage,
   type GetLangfuseSessionsQuery,
   type GetLangfuseSessionsResponse,
+  type GetLangfuseScoresQuery,
+  type GetLangfuseScoresResponse,
+  type GetLangfusePromptsQuery,
+  type GetLangfusePromptsResponse,
+  type GetLangfuseDatasetsQuery,
+  type GetLangfuseDatasetsResponse,
+  type GetLangfuseScoreResponse,
 } from "./types";
 import {
   generateUUID,
@@ -339,6 +346,36 @@ abstract class LangfuseCoreStateless {
     return { data, meta };
   }
 
+  async fetchScore(scoreId: string): Promise<{ data: GetLangfuseScoreResponse }> {
+    const res = await this.fetch(
+      `${this.baseUrl}/api/public/scores/${scoreId}`,
+      this._getFetchOptions({ method: "GET" })
+    );
+
+    const score = (await res.json()) as GetLangfuseScoreResponse;
+    return { data: score };
+  }
+
+  async fetchScores(query?: GetLangfuseScoresQuery): Promise<GetLangfuseScoresResponse> {
+    const res = await this.fetch(
+      `${this.baseUrl}/api/public/scores?${encodeQueryParams(query)}`,
+      this._getFetchOptions({ method: "GET" })
+    );
+    // destructure the response into data and meta to be explicit about the shape of the response and add type-warnings in case the API changes
+    const { data, meta } = (await res.json()) as GetLangfuseScoresResponse;
+    return { data, meta };
+  }
+
+  async fetchPrompts(query?: GetLangfusePromptsQuery): Promise<GetLangfusePromptsResponse> {
+    const res = await this.fetch(
+      `${this.baseUrl}/api/public/v2/prompts?${encodeQueryParams(query)}`,
+      this._getFetchOptions({ method: "GET" })
+    );
+    // destructure the response into data and meta to be explicit about the shape of the response and add type-warnings in case the API changes
+    const { data, meta } = (await res.json()) as GetLangfusePromptsResponse;
+    return { data, meta };
+  }
+
   async getDatasetRun(params: GetLangfuseDatasetRunParams): Promise<GetLangfuseDatasetRunResponse> {
     const encodedDatasetName = encodeURIComponent(params.datasetName);
     const encodedRunName = encodeURIComponent(params.runName);
@@ -405,6 +442,13 @@ abstract class LangfuseCoreStateless {
     );
   }
 
+  async getDatasetItems(query?: GetLangfuseDatasetItemsQuery): Promise<GetLangfuseDatasetItemsResponse> {
+    return this.fetch(
+      `${this.baseUrl}/api/public/dataset-items?${encodeQueryParams(query)}`,
+      this._getFetchOptions({ method: "GET" })
+    ).then((res) => res.json());
+  }
+
   protected _parsePayload(response: any): any {
     try {
       return JSON.parse(response);
@@ -874,6 +918,13 @@ export abstract class LangfuseCore extends LangfuseCoreStateless {
     return this;
   }
 
+  async getDatasets(query?: GetLangfuseDatasetsQuery): Promise<GetLangfuseDatasetsResponse> {
+    return this.fetch(
+      `${this.baseUrl}/api/public/datasets?${encodeQueryParams(query)}`,
+      this._getFetchOptions({ method: "GET" })
+    ).then((res) => res.json());
+  }
+
   async getDataset(
     name: string,
     options?: {

langfuse-core/src/types.ts

@@ -99,12 +99,27 @@ export type GetLangfuseSessionsQuery = FixTypes<paths["/api/public/sessions"]["g
 export type GetLangfuseSessionsResponse = FixTypes<
   paths["/api/public/sessions"]["get"]["responses"]["200"]["content"]["application/json"]
 >;
+export type GetLangfuseScoreResponse = FixTypes<
+  paths["/api/public/scores/{scoreId}"]["get"]["responses"]["200"]["content"]["application/json"]
+>;
+export type GetLangfuseScoresQuery = FixTypes<paths["/api/public/scores"]["get"]["parameters"]["query"]>;
+export type GetLangfuseScoresResponse = FixTypes<
+  paths["/api/public/scores"]["get"]["responses"]["200"]["content"]["application/json"]
+>;
+export type GetLangfusePromptsQuery = FixTypes<paths["/api/public/v2/prompts"]["get"]["parameters"]["query"]>;
+export type GetLangfusePromptsResponse = FixTypes<
+  paths["/api/public/v2/prompts"]["get"]["responses"]["200"]["content"]["application/json"]
+>;
 export type GetLangfuseDatasetParams = FixTypes<
   paths["/api/public/v2/datasets/{datasetName}"]["get"]["parameters"]["path"]
 >;
 export type GetLangfuseDatasetResponse = FixTypes<
   paths["/api/public/v2/datasets/{datasetName}"]["get"]["responses"]["200"]["content"]["application/json"]
 >;
+export type GetLangfuseDatasetsQuery = FixTypes<paths["/api/public/v2/datasets"]["get"]["parameters"]["query"]>;
+export type GetLangfuseDatasetsResponse = FixTypes<
+  paths["/api/public/v2/datasets"]["get"]["responses"]["200"]["content"]["application/json"]
+>;
 export type GetLangfuseDatasetItemsQuery = paths["/api/public/dataset-items"]["get"]["parameters"]["query"];
 export type GetLangfuseDatasetItemsResponse = FixTypes<
   paths["/api/public/dataset-items"]["get"]["responses"]["200"]["content"]["application/json"]