README.md

Trace

Overview

Available Operations

• logTracesProjectsProjectIdTracesPost - Log Traces
• updateTraceProjectsProjectIdTracesTraceIdPatch - Update Trace
• getTraceProjectsProjectIdTracesTraceIdGet - Get Trace
• updateSpanProjectsProjectIdSpansSpanIdPatch - Update Span
• getSpanProjectsProjectIdSpansSpanIdGet - Get Span
• tracesAvailableColumnsProjectsProjectIdTracesAvailableColumnsPost - Traces Available Columns
• metricsTestingAvailableColumnsProjectsProjectIdMetricsTestingAvailableColumnsPost - Metrics Testing Available Columns
• spansAvailableColumnsProjectsProjectIdSpansAvailableColumnsPost - Spans Available Columns
• queryTracesProjectsProjectIdTracesSearchPost - Query Traces
• queryPartialTracesProjectsProjectIdTracesPartialSearchPost - Query Partial Traces
• countTracesProjectsProjectIdTracesCountPost - Count Traces
• logSpansProjectsProjectIdSpansPost - Log Spans
• querySpansProjectsProjectIdSpansSearchPost - Query Spans
• queryPartialSpansProjectsProjectIdSpansPartialSearchPost - Query Partial Spans
• countSpansProjectsProjectIdSpansCountPost - Count Spans
• queryMetricsProjectsProjectIdMetricsSearchPost - Query Metrics
• createSessionProjectsProjectIdSessionsPost - Create Session
• querySessionsProjectsProjectIdSessionsSearchPost - Query Sessions
• queryPartialSessionsProjectsProjectIdSessionsPartialSearchPost - Query Partial Sessions
• countSessionsProjectsProjectIdSessionsCountPost - Count Sessions
• getSessionProjectsProjectIdSessionsSessionIdGet - Get Session
• sessionsAvailableColumnsProjectsProjectIdSessionsAvailableColumnsPost - Sessions Available Columns
• getAggregatedTraceViewProjectsProjectIdTracesAggregatedPost - Get Aggregated Trace View
• exportRecordsProjectsProjectIdExportRecordsPost - Export Records
• recomputeMetricsProjectsProjectIdRecomputeMetricsPost - Recompute Metrics
• deleteTracesProjectsProjectIdTracesDeletePost - Delete Traces
• deleteSpansProjectsProjectIdSpansDeletePost - Delete Spans
• deleteSessionsProjectsProjectIdSessionsDeletePost - Delete Sessions

logTracesProjectsProjectIdTracesPost

Log Traces

Example Usage

import { GalileoGenerated } from "galileo-generated";

const galileoGenerated = new GalileoGenerated();

async function run() {
  const result = await galileoGenerated.trace.logTracesProjectsProjectIdTracesPost({
    apiKeyHeader: process.env["GALILEOGENERATED_API_KEY_HEADER"] ?? "",
  }, {
    projectId: "<value>",
    body: {
      logStreamId: "00000000-0000-0000-0000-000000000000",
      sessionId: "00000000-0000-0000-0000-000000000000",
      traces: [
        {
          input: "who is a smart LLM?",
          output: "I am!",
          createdAt: new Date("2026-01-28T00:17:57.438225Z"),
          userMetadata: {

          },
          tags: [],
          metrics: {},
          datasetMetadata: {

          },
          spans: [
            {
              type: "llm",
              input: [
                {
                  content: "Question: who is a smart LLM?",
                  role: "user",
                },
              ],
              output: {
                content: "I am!",
                role: "user",
              },
              name: "",
              createdAt: new Date("2026-01-28T00:17:57.438190Z"),
              userMetadata: {

              },
              tags: [],
              metrics: {},
              datasetMetadata: {

              },
            },
          ],
        },
      ],
    },
  });

  console.log(result);
}

run();

Standalone function

The standalone function version of this method:

import { GalileoGeneratedCore } from "galileo-generated/core.js";
import { traceLogTracesProjectsProjectIdTracesPost } from "galileo-generated/funcs/traceLogTracesProjectsProjectIdTracesPost.js";

// Use `GalileoGeneratedCore` for best tree-shaking performance.
// You can create one instance of it to use across an application.
const galileoGenerated = new GalileoGeneratedCore();

async function run() {
  const res = await traceLogTracesProjectsProjectIdTracesPost(galileoGenerated, {
    apiKeyHeader: process.env["GALILEOGENERATED_API_KEY_HEADER"] ?? "",
  }, {
    projectId: "<value>",
    body: {
      logStreamId: "00000000-0000-0000-0000-000000000000",
      sessionId: "00000000-0000-0000-0000-000000000000",
      traces: [
        {
          input: "who is a smart LLM?",
          output: "I am!",
          createdAt: new Date("2026-01-28T00:17:57.438225Z"),
          userMetadata: {
  
          },
          tags: [],
          metrics: {},
          datasetMetadata: {
  
          },
          spans: [
            {
              type: "llm",
              input: [
                {
                  content: "Question: who is a smart LLM?",
                  role: "user",
                },
              ],
              output: {
                content: "I am!",
                role: "user",
              },
              name: "",
              createdAt: new Date("2026-01-28T00:17:57.438190Z"),
              userMetadata: {
  
              },
              tags: [],
              metrics: {},
              datasetMetadata: {
  
              },
            },
          ],
        },
      ],
    },
  });
  if (res.ok) {
    const { value: result } = res;
    console.log(result);
  } else {
    console.log("traceLogTracesProjectsProjectIdTracesPost failed:", res.error);
  }
}

run();

Parameters

Parameter	Type	Required	Description
request	operations.LogTracesProjectsProjectIdTracesPostRequest	✔️	The request object to use for the request.
security	operations.LogTracesProjectsProjectIdTracesPostSecurity	✔️	The security requirements to use for the request.
options	RequestOptions	➖	Used to set various options for making HTTP requests.
options.fetchOptions	RequestInit	➖	Options that are passed to the underlying HTTP request. This can be used to inject extra headers for examples. All Request options, except method and body, are allowed.
options.retries	RetryConfig	➖	Enables retrying HTTP requests under certain failure conditions.

Response

Promise<models.LogTracesIngestResponse>

Errors

Error Type	Status Code	Content Type
errors.HTTPValidationError	422	application/json
errors.GalileoGeneratedDefaultError	4XX, 5XX	*/*

updateTraceProjectsProjectIdTracesTraceIdPatch

Update a trace with the given ID.

Example Usage

import { GalileoGenerated } from "galileo-generated";

const galileoGenerated = new GalileoGenerated();

async function run() {
  const result = await galileoGenerated.trace.updateTraceProjectsProjectIdTracesTraceIdPatch({
    apiKeyHeader: process.env["GALILEOGENERATED_API_KEY_HEADER"] ?? "",
  }, {
    traceId: "<value>",
    projectId: "<value>",
    body: {
      traceId: "<value>",
    },
  });

  console.log(result);
}

run();

Standalone function

The standalone function version of this method:

import { GalileoGeneratedCore } from "galileo-generated/core.js";
import { traceUpdateTraceProjectsProjectIdTracesTraceIdPatch } from "galileo-generated/funcs/traceUpdateTraceProjectsProjectIdTracesTraceIdPatch.js";

// Use `GalileoGeneratedCore` for best tree-shaking performance.
// You can create one instance of it to use across an application.
const galileoGenerated = new GalileoGeneratedCore();

async function run() {
  const res = await traceUpdateTraceProjectsProjectIdTracesTraceIdPatch(galileoGenerated, {
    apiKeyHeader: process.env["GALILEOGENERATED_API_KEY_HEADER"] ?? "",
  }, {
    traceId: "<value>",
    projectId: "<value>",
    body: {
      traceId: "<value>",
    },
  });
  if (res.ok) {
    const { value: result } = res;
    console.log(result);
  } else {
    console.log("traceUpdateTraceProjectsProjectIdTracesTraceIdPatch failed:", res.error);
  }
}

run();

Parameters

Parameter	Type	Required	Description
request	operations.UpdateTraceProjectsProjectIdTracesTraceIdPatchRequest	✔️	The request object to use for the request.
security	operations.UpdateTraceProjectsProjectIdTracesTraceIdPatchSecurity	✔️	The security requirements to use for the request.
options	RequestOptions	➖	Used to set various options for making HTTP requests.
options.fetchOptions	RequestInit	➖	Options that are passed to the underlying HTTP request. This can be used to inject extra headers for examples. All Request options, except method and body, are allowed.
options.retries	RetryConfig	➖	Enables retrying HTTP requests under certain failure conditions.

Response

Promise<models.LogTraceUpdateResponse>

Errors

Error Type	Status Code	Content Type
errors.HTTPValidationError	422	application/json
errors.GalileoGeneratedDefaultError	4XX, 5XX	*/*

getTraceProjectsProjectIdTracesTraceIdGet

Get Trace

Example Usage

import { GalileoGenerated } from "galileo-generated";

const galileoGenerated = new GalileoGenerated();

async function run() {
  const result = await galileoGenerated.trace.getTraceProjectsProjectIdTracesTraceIdGet({
    apiKeyHeader: process.env["GALILEOGENERATED_API_KEY_HEADER"] ?? "",
  }, {
    traceId: "<value>",
    projectId: "<value>",
  });

  console.log(result);
}

run();

Standalone function

The standalone function version of this method:

import { GalileoGeneratedCore } from "galileo-generated/core.js";
import { traceGetTraceProjectsProjectIdTracesTraceIdGet } from "galileo-generated/funcs/traceGetTraceProjectsProjectIdTracesTraceIdGet.js";

// Use `GalileoGeneratedCore` for best tree-shaking performance.
// You can create one instance of it to use across an application.
const galileoGenerated = new GalileoGeneratedCore();

async function run() {
  const res = await traceGetTraceProjectsProjectIdTracesTraceIdGet(galileoGenerated, {
    apiKeyHeader: process.env["GALILEOGENERATED_API_KEY_HEADER"] ?? "",
  }, {
    traceId: "<value>",
    projectId: "<value>",
  });
  if (res.ok) {
    const { value: result } = res;
    console.log(result);
  } else {
    console.log("traceGetTraceProjectsProjectIdTracesTraceIdGet failed:", res.error);
  }
}

run();

Parameters

Parameter	Type	Required	Description
request	operations.GetTraceProjectsProjectIdTracesTraceIdGetRequest	✔️	The request object to use for the request.
security	operations.GetTraceProjectsProjectIdTracesTraceIdGetSecurity	✔️	The security requirements to use for the request.
options	RequestOptions	➖	Used to set various options for making HTTP requests.
options.fetchOptions	RequestInit	➖	Options that are passed to the underlying HTTP request. This can be used to inject extra headers for examples. All Request options, except method and body, are allowed.
options.retries	RetryConfig	➖	Enables retrying HTTP requests under certain failure conditions.

Response

Promise<models.ExtendedTraceRecordWithChildren>

Errors

Error Type	Status Code	Content Type
errors.HTTPValidationError	422	application/json
errors.GalileoGeneratedDefaultError	4XX, 5XX	*/*

updateSpanProjectsProjectIdSpansSpanIdPatch

Update a span with the given ID.

Example Usage

import { GalileoGenerated } from "galileo-generated";

const galileoGenerated = new GalileoGenerated();

async function run() {
  const result = await galileoGenerated.trace.updateSpanProjectsProjectIdSpansSpanIdPatch({
    apiKeyHeader: process.env["GALILEOGENERATED_API_KEY_HEADER"] ?? "",
  }, {
    spanId: "<value>",
    projectId: "<value>",
    body: {
      spanId: "<value>",
    },
  });

  console.log(result);
}

run();

Standalone function

The standalone function version of this method:

import { GalileoGeneratedCore } from "galileo-generated/core.js";
import { traceUpdateSpanProjectsProjectIdSpansSpanIdPatch } from "galileo-generated/funcs/traceUpdateSpanProjectsProjectIdSpansSpanIdPatch.js";

// Use `GalileoGeneratedCore` for best tree-shaking performance.
// You can create one instance of it to use across an application.
const galileoGenerated = new GalileoGeneratedCore();

async function run() {
  const res = await traceUpdateSpanProjectsProjectIdSpansSpanIdPatch(galileoGenerated, {
    apiKeyHeader: process.env["GALILEOGENERATED_API_KEY_HEADER"] ?? "",
  }, {
    spanId: "<value>",
    projectId: "<value>",
    body: {
      spanId: "<value>",
    },
  });
  if (res.ok) {
    const { value: result } = res;
    console.log(result);
  } else {
    console.log("traceUpdateSpanProjectsProjectIdSpansSpanIdPatch failed:", res.error);
  }
}

run();

Parameters

Parameter	Type	Required	Description
request	operations.UpdateSpanProjectsProjectIdSpansSpanIdPatchRequest	✔️	The request object to use for the request.
security	operations.UpdateSpanProjectsProjectIdSpansSpanIdPatchSecurity	✔️	The security requirements to use for the request.
options	RequestOptions	➖	Used to set various options for making HTTP requests.
options.fetchOptions	RequestInit	➖	Options that are passed to the underlying HTTP request. This can be used to inject extra headers for examples. All Request options, except method and body, are allowed.
options.retries	RetryConfig	➖	Enables retrying HTTP requests under certain failure conditions.

Response

Promise<models.LogSpanUpdateResponse>

Errors

Error Type	Status Code	Content Type
errors.HTTPValidationError	422	application/json
errors.GalileoGeneratedDefaultError	4XX, 5XX	*/*

getSpanProjectsProjectIdSpansSpanIdGet

Get Span

Example Usage

import { GalileoGenerated } from "galileo-generated";

const galileoGenerated = new GalileoGenerated();

async function run() {
  const result = await galileoGenerated.trace.getSpanProjectsProjectIdSpansSpanIdGet({
    apiKeyHeader: process.env["GALILEOGENERATED_API_KEY_HEADER"] ?? "",
  }, {
    spanId: "<value>",
    projectId: "<value>",
  });

  console.log(result);
}

run();

Standalone function

The standalone function version of this method:

import { GalileoGeneratedCore } from "galileo-generated/core.js";
import { traceGetSpanProjectsProjectIdSpansSpanIdGet } from "galileo-generated/funcs/traceGetSpanProjectsProjectIdSpansSpanIdGet.js";

// Use `GalileoGeneratedCore` for best tree-shaking performance.
// You can create one instance of it to use across an application.
const galileoGenerated = new GalileoGeneratedCore();

async function run() {
  const res = await traceGetSpanProjectsProjectIdSpansSpanIdGet(galileoGenerated, {
    apiKeyHeader: process.env["GALILEOGENERATED_API_KEY_HEADER"] ?? "",
  }, {
    spanId: "<value>",
    projectId: "<value>",
  });
  if (res.ok) {
    const { value: result } = res;
    console.log(result);
  } else {
    console.log("traceGetSpanProjectsProjectIdSpansSpanIdGet failed:", res.error);
  }
}

run();

Parameters

Parameter	Type	Required	Description
request	operations.GetSpanProjectsProjectIdSpansSpanIdGetRequest	✔️	The request object to use for the request.
security	operations.GetSpanProjectsProjectIdSpansSpanIdGetSecurity	✔️	The security requirements to use for the request.
options	RequestOptions	➖	Used to set various options for making HTTP requests.
options.fetchOptions	RequestInit	➖	Options that are passed to the underlying HTTP request. This can be used to inject extra headers for examples. All Request options, except method and body, are allowed.
options.retries	RetryConfig	➖	Enables retrying HTTP requests under certain failure conditions.

Response

Promise<operations.ResponseGetSpanProjectsProjectIdSpansSpanIdGet>

Errors

Error Type	Status Code	Content Type
errors.HTTPValidationError	422	application/json
errors.GalileoGeneratedDefaultError	4XX, 5XX	*/*

tracesAvailableColumnsProjectsProjectIdTracesAvailableColumnsPost

Traces Available Columns

Example Usage

import { GalileoGenerated } from "galileo-generated";

const galileoGenerated = new GalileoGenerated();

async function run() {
  const result = await galileoGenerated.trace.tracesAvailableColumnsProjectsProjectIdTracesAvailableColumnsPost({
    apiKeyHeader: process.env["GALILEOGENERATED_API_KEY_HEADER"] ?? "",
  }, {
    projectId: "<value>",
    body: {
      logStreamId: "00000000-0000-0000-0000-000000000000",
    },
  });

  console.log(result);
}

run();

Standalone function

The standalone function version of this method:

import { GalileoGeneratedCore } from "galileo-generated/core.js";
import { traceTracesAvailableColumnsProjectsProjectIdTracesAvailableColumnsPost } from "galileo-generated/funcs/traceTracesAvailableColumnsProjectsProjectIdTracesAvailableColumnsPost.js";

// Use `GalileoGeneratedCore` for best tree-shaking performance.
// You can create one instance of it to use across an application.
const galileoGenerated = new GalileoGeneratedCore();

async function run() {
  const res = await traceTracesAvailableColumnsProjectsProjectIdTracesAvailableColumnsPost(galileoGenerated, {
    apiKeyHeader: process.env["GALILEOGENERATED_API_KEY_HEADER"] ?? "",
  }, {
    projectId: "<value>",
    body: {
      logStreamId: "00000000-0000-0000-0000-000000000000",
    },
  });
  if (res.ok) {
    const { value: result } = res;
    console.log(result);
  } else {
    console.log("traceTracesAvailableColumnsProjectsProjectIdTracesAvailableColumnsPost failed:", res.error);
  }
}

run();

Parameters

Parameter	Type	Required	Description
request	operations.TracesAvailableColumnsProjectsProjectIdTracesAvailableColumnsPostRequest	✔️	The request object to use for the request.
security	operations.TracesAvailableColumnsProjectsProjectIdTracesAvailableColumnsPostSecurity	✔️	The security requirements to use for the request.
options	RequestOptions	➖	Used to set various options for making HTTP requests.
options.fetchOptions	RequestInit	➖	Options that are passed to the underlying HTTP request. This can be used to inject extra headers for examples. All Request options, except method and body, are allowed.
options.retries	RetryConfig	➖	Enables retrying HTTP requests under certain failure conditions.

Response

Promise<models.LogRecordsAvailableColumnsResponse>

Errors

Error Type	Status Code	Content Type
errors.HTTPValidationError	422	application/json
errors.GalileoGeneratedDefaultError	4XX, 5XX	*/*

metricsTestingAvailableColumnsProjectsProjectIdMetricsTestingAvailableColumnsPost

Metrics Testing Available Columns

Example Usage

import { GalileoGenerated } from "galileo-generated";

const galileoGenerated = new GalileoGenerated();

async function run() {
  const result = await galileoGenerated.trace.metricsTestingAvailableColumnsProjectsProjectIdMetricsTestingAvailableColumnsPost({
    apiKeyHeader: process.env["GALILEOGENERATED_API_KEY_HEADER"] ?? "",
  }, {
    projectId: "<value>",
    body: {
      name: "<value>",
    },
  });

  console.log(result);
}

run();

Standalone function

The standalone function version of this method:

import { GalileoGeneratedCore } from "galileo-generated/core.js";
import {
  traceMetricsTestingAvailableColumnsProjectsProjectIdMetricsTestingAvailableColumnsPost,
} from "galileo-generated/funcs/traceMetricsTestingAvailableColumnsProjectsProjectIdMetricsTestingAvailableColumnsPost.js";

// Use `GalileoGeneratedCore` for best tree-shaking performance.
// You can create one instance of it to use across an application.
const galileoGenerated = new GalileoGeneratedCore();

async function run() {
  const res = await traceMetricsTestingAvailableColumnsProjectsProjectIdMetricsTestingAvailableColumnsPost(galileoGenerated, {
    apiKeyHeader: process.env["GALILEOGENERATED_API_KEY_HEADER"] ?? "",
  }, {
    projectId: "<value>",
    body: {
      name: "<value>",
    },
  });
  if (res.ok) {
    const { value: result } = res;
    console.log(result);
  } else {
    console.log("traceMetricsTestingAvailableColumnsProjectsProjectIdMetricsTestingAvailableColumnsPost failed:", res.error);
  }
}

run();

Parameters

Parameter	Type	Required	Description
request	operations.MetricsTestingAvailableColumnsProjectsProjectIdMetricsTestingAvailableColumnsPostRequest	✔️	The request object to use for the request.
security	operations.MetricsTestingAvailableColumnsProjectsProjectIdMetricsTestingAvailableColumnsPostSecurity	✔️	The security requirements to use for the request.
options	RequestOptions	➖	Used to set various options for making HTTP requests.
options.fetchOptions	RequestInit	➖	Options that are passed to the underlying HTTP request. This can be used to inject extra headers for examples. All Request options, except method and body, are allowed.
options.retries	RetryConfig	➖	Enables retrying HTTP requests under certain failure conditions.

Response

Promise<models.LogRecordsAvailableColumnsResponse>

Errors

Error Type	Status Code	Content Type
errors.HTTPValidationError	422	application/json
errors.GalileoGeneratedDefaultError	4XX, 5XX	*/*

spansAvailableColumnsProjectsProjectIdSpansAvailableColumnsPost

Spans Available Columns

Example Usage

import { GalileoGenerated } from "galileo-generated";

const galileoGenerated = new GalileoGenerated();

async function run() {
  const result = await galileoGenerated.trace.spansAvailableColumnsProjectsProjectIdSpansAvailableColumnsPost({
    apiKeyHeader: process.env["GALILEOGENERATED_API_KEY_HEADER"] ?? "",
  }, {
    projectId: "<value>",
    body: {
      logStreamId: "00000000-0000-0000-0000-000000000000",
    },
  });

  console.log(result);
}

run();

Standalone function

The standalone function version of this method:

import { GalileoGeneratedCore } from "galileo-generated/core.js";
import { traceSpansAvailableColumnsProjectsProjectIdSpansAvailableColumnsPost } from "galileo-generated/funcs/traceSpansAvailableColumnsProjectsProjectIdSpansAvailableColumnsPost.js";

// Use `GalileoGeneratedCore` for best tree-shaking performance.
// You can create one instance of it to use across an application.
const galileoGenerated = new GalileoGeneratedCore();

async function run() {
  const res = await traceSpansAvailableColumnsProjectsProjectIdSpansAvailableColumnsPost(galileoGenerated, {
    apiKeyHeader: process.env["GALILEOGENERATED_API_KEY_HEADER"] ?? "",
  }, {
    projectId: "<value>",
    body: {
      logStreamId: "00000000-0000-0000-0000-000000000000",
    },
  });
  if (res.ok) {
    const { value: result } = res;
    console.log(result);
  } else {
    console.log("traceSpansAvailableColumnsProjectsProjectIdSpansAvailableColumnsPost failed:", res.error);
  }
}

run();

Parameters

Parameter	Type	Required	Description
request	operations.SpansAvailableColumnsProjectsProjectIdSpansAvailableColumnsPostRequest	✔️	The request object to use for the request.
security	operations.SpansAvailableColumnsProjectsProjectIdSpansAvailableColumnsPostSecurity	✔️	The security requirements to use for the request.
options	RequestOptions	➖	Used to set various options for making HTTP requests.
options.fetchOptions	RequestInit	➖	Options that are passed to the underlying HTTP request. This can be used to inject extra headers for examples. All Request options, except method and body, are allowed.
options.retries	RetryConfig	➖	Enables retrying HTTP requests under certain failure conditions.

Response

Promise<models.LogRecordsAvailableColumnsResponse>

Errors

Error Type	Status Code	Content Type
errors.HTTPValidationError	422	application/json
errors.GalileoGeneratedDefaultError	4XX, 5XX	*/*

queryTracesProjectsProjectIdTracesSearchPost

Query Traces

Example Usage

import { GalileoGenerated } from "galileo-generated";

const galileoGenerated = new GalileoGenerated();

async function run() {
  const result = await galileoGenerated.trace.queryTracesProjectsProjectIdTracesSearchPost({
    apiKeyHeader: process.env["GALILEOGENERATED_API_KEY_HEADER"] ?? "",
  }, {
    projectId: "<value>",
    body: {
      logStreamId: "00000000-0000-0000-0000-000000000000",
      filters: [
        {
          columnId: "<id>",
          operator: "eq",
          value: "example input",
          caseSensitive: true,
          type: "text",
        },
      ],
      sort: {
        columnId: "<id>",
        ascending: false,
      },
    },
  });

  console.log(result);
}

run();

Standalone function

The standalone function version of this method:

import { GalileoGeneratedCore } from "galileo-generated/core.js";
import { traceQueryTracesProjectsProjectIdTracesSearchPost } from "galileo-generated/funcs/traceQueryTracesProjectsProjectIdTracesSearchPost.js";

// Use `GalileoGeneratedCore` for best tree-shaking performance.
// You can create one instance of it to use across an application.
const galileoGenerated = new GalileoGeneratedCore();

async function run() {
  const res = await traceQueryTracesProjectsProjectIdTracesSearchPost(galileoGenerated, {
    apiKeyHeader: process.env["GALILEOGENERATED_API_KEY_HEADER"] ?? "",
  }, {
    projectId: "<value>",
    body: {
      logStreamId: "00000000-0000-0000-0000-000000000000",
      filters: [
        {
          columnId: "<id>",
          operator: "eq",
          value: "example input",
          caseSensitive: true,
          type: "text",
        },
      ],
      sort: {
        columnId: "<id>",
        ascending: false,
      },
    },
  });
  if (res.ok) {
    const { value: result } = res;
    console.log(result);
  } else {
    console.log("traceQueryTracesProjectsProjectIdTracesSearchPost failed:", res.error);
  }
}

run();

Parameters

Parameter	Type	Required	Description
request	operations.QueryTracesProjectsProjectIdTracesSearchPostRequest	✔️	The request object to use for the request.
security	operations.QueryTracesProjectsProjectIdTracesSearchPostSecurity	✔️	The security requirements to use for the request.
options	RequestOptions	➖	Used to set various options for making HTTP requests.
options.fetchOptions	RequestInit	➖	Options that are passed to the underlying HTTP request. This can be used to inject extra headers for examples. All Request options, except method and body, are allowed.
options.retries	RetryConfig	➖	Enables retrying HTTP requests under certain failure conditions.

Response

Promise<models.LogRecordsQueryResponse>

Errors

Error Type	Status Code	Content Type
errors.HTTPValidationError	422	application/json
errors.GalileoGeneratedDefaultError	4XX, 5XX	*/*

queryPartialTracesProjectsProjectIdTracesPartialSearchPost

Query Partial Traces

Example Usage

import { GalileoGenerated } from "galileo-generated";

const galileoGenerated = new GalileoGenerated();

async function run() {
  const result = await galileoGenerated.trace.queryPartialTracesProjectsProjectIdTracesPartialSearchPost({
    apiKeyHeader: process.env["GALILEOGENERATED_API_KEY_HEADER"] ?? "",
  }, {
    projectId: "<value>",
    body: {
      logStreamId: "00000000-0000-0000-0000-000000000000",
      filters: [
        {
          columnId: "<id>",
          operator: "eq",
          value: "example input",
          caseSensitive: true,
          type: "text",
        },
      ],
      sort: {
        columnId: "<id>",
        ascending: false,
      },
      selectColumns: {
        columnIds: [
          "id",
          "metrics/agentic_session_success",
          "metrics/completeness_gpt",
        ],
      },
    },
  });

  console.log(result);
}

run();

Standalone function

The standalone function version of this method:

import { GalileoGeneratedCore } from "galileo-generated/core.js";
import { traceQueryPartialTracesProjectsProjectIdTracesPartialSearchPost } from "galileo-generated/funcs/traceQueryPartialTracesProjectsProjectIdTracesPartialSearchPost.js";

// Use `GalileoGeneratedCore` for best tree-shaking performance.
// You can create one instance of it to use across an application.
const galileoGenerated = new GalileoGeneratedCore();

async function run() {
  const res = await traceQueryPartialTracesProjectsProjectIdTracesPartialSearchPost(galileoGenerated, {
    apiKeyHeader: process.env["GALILEOGENERATED_API_KEY_HEADER"] ?? "",
  }, {
    projectId: "<value>",
    body: {
      logStreamId: "00000000-0000-0000-0000-000000000000",
      filters: [
        {
          columnId: "<id>",
          operator: "eq",
          value: "example input",
          caseSensitive: true,
          type: "text",
        },
      ],
      sort: {
        columnId: "<id>",
        ascending: false,
      },
      selectColumns: {
        columnIds: [
          "id",
          "metrics/agentic_session_success",
          "metrics/completeness_gpt",
        ],
      },
    },
  });
  if (res.ok) {
    const { value: result } = res;
    console.log(result);
  } else {
    console.log("traceQueryPartialTracesProjectsProjectIdTracesPartialSearchPost failed:", res.error);
  }
}

run();

Parameters

Parameter	Type	Required	Description
request	operations.QueryPartialTracesProjectsProjectIdTracesPartialSearchPostRequest	✔️	The request object to use for the request.
security	operations.QueryPartialTracesProjectsProjectIdTracesPartialSearchPostSecurity	✔️	The security requirements to use for the request.
options	RequestOptions	➖	Used to set various options for making HTTP requests.
options.fetchOptions	RequestInit	➖	Options that are passed to the underlying HTTP request. This can be used to inject extra headers for examples. All Request options, except method and body, are allowed.
options.retries	RetryConfig	➖	Enables retrying HTTP requests under certain failure conditions.

Response

Promise<models.LogRecordsPartialQueryResponse>

Errors

Error Type	Status Code	Content Type
errors.HTTPValidationError	422	application/json
errors.GalileoGeneratedDefaultError	4XX, 5XX	*/*

countTracesProjectsProjectIdTracesCountPost

This endpoint may return a slightly inaccurate count due to the way records are filtered before deduplication.

Example Usage

import { GalileoGenerated } from "galileo-generated";

const galileoGenerated = new GalileoGenerated();

async function run() {
  const result = await galileoGenerated.trace.countTracesProjectsProjectIdTracesCountPost({
    apiKeyHeader: process.env["GALILEOGENERATED_API_KEY_HEADER"] ?? "",
  }, {
    projectId: "<value>",
    body: {
      logStreamId: "74aec44e-ec21-4c9f-a3e2-b2ab2b81b4db",
      filters: [
        {
          columnId: "<id>",
          operator: "eq",
          value: "example input",
          caseSensitive: true,
          type: "text",
        },
      ],
    },
  });

  console.log(result);
}

run();

Standalone function

The standalone function version of this method:

import { GalileoGeneratedCore } from "galileo-generated/core.js";
import { traceCountTracesProjectsProjectIdTracesCountPost } from "galileo-generated/funcs/traceCountTracesProjectsProjectIdTracesCountPost.js";

// Use `GalileoGeneratedCore` for best tree-shaking performance.
// You can create one instance of it to use across an application.
const galileoGenerated = new GalileoGeneratedCore();

async function run() {
  const res = await traceCountTracesProjectsProjectIdTracesCountPost(galileoGenerated, {
    apiKeyHeader: process.env["GALILEOGENERATED_API_KEY_HEADER"] ?? "",
  }, {
    projectId: "<value>",
    body: {
      logStreamId: "74aec44e-ec21-4c9f-a3e2-b2ab2b81b4db",
      filters: [
        {
          columnId: "<id>",
          operator: "eq",
          value: "example input",
          caseSensitive: true,
          type: "text",
        },
      ],
    },
  });
  if (res.ok) {
    const { value: result } = res;
    console.log(result);
  } else {
    console.log("traceCountTracesProjectsProjectIdTracesCountPost failed:", res.error);
  }
}

run();

Parameters

Parameter	Type	Required	Description
request	operations.CountTracesProjectsProjectIdTracesCountPostRequest	✔️	The request object to use for the request.
security	operations.CountTracesProjectsProjectIdTracesCountPostSecurity	✔️	The security requirements to use for the request.
options	RequestOptions	➖	Used to set various options for making HTTP requests.
options.fetchOptions	RequestInit	➖	Options that are passed to the underlying HTTP request. This can be used to inject extra headers for examples. All Request options, except method and body, are allowed.
options.retries	RetryConfig	➖	Enables retrying HTTP requests under certain failure conditions.

Response

Promise<models.LogRecordsQueryCountResponse>

Errors

Error Type	Status Code	Content Type
errors.HTTPValidationError	422	application/json
errors.GalileoGeneratedDefaultError	4XX, 5XX	*/*

logSpansProjectsProjectIdSpansPost

Log Spans

Example Usage

import { GalileoGenerated } from "galileo-generated";

const galileoGenerated = new GalileoGenerated();

async function run() {
  const result = await galileoGenerated.trace.logSpansProjectsProjectIdSpansPost({
    apiKeyHeader: process.env["GALILEOGENERATED_API_KEY_HEADER"] ?? "",
  }, {
    projectId: "<value>",
    body: {
      logStreamId: "00000000-0000-0000-0000-000000000000",
      spans: [
        {
          type: "workflow",
          input: "who is a smart LLM?",
          output: "I am!",
          name: "",
          createdAt: new Date("2026-01-28T00:17:57.458322Z"),
          userMetadata: {

          },
          tags: [],
          metrics: {},
          datasetMetadata: {

          },
          spans: [
            {
              type: "llm",
              input: [
                {
                  content: "Question: who is a smart LLM?",
                  role: "user",
                },
              ],
              output: {
                content: "I am!",
                role: "user",
              },
              name: "",
              createdAt: new Date("2026-01-28T00:17:57.444313Z"),
              userMetadata: {

              },
              tags: [],
              metrics: {},
              datasetMetadata: {

              },
              id: "22222222-2222-4222-a222-222222222222",
            },
          ],
        },
      ],
      traceId: "11000011-0000-0000-0000-110000110000",
      parentId: "11000011-0000-0000-0000-110000110000",
    },
  });

  console.log(result);
}

run();

Standalone function

The standalone function version of this method:

import { GalileoGeneratedCore } from "galileo-generated/core.js";
import { traceLogSpansProjectsProjectIdSpansPost } from "galileo-generated/funcs/traceLogSpansProjectsProjectIdSpansPost.js";

// Use `GalileoGeneratedCore` for best tree-shaking performance.
// You can create one instance of it to use across an application.
const galileoGenerated = new GalileoGeneratedCore();

async function run() {
  const res = await traceLogSpansProjectsProjectIdSpansPost(galileoGenerated, {
    apiKeyHeader: process.env["GALILEOGENERATED_API_KEY_HEADER"] ?? "",
  }, {
    projectId: "<value>",
    body: {
      logStreamId: "00000000-0000-0000-0000-000000000000",
      spans: [
        {
          type: "workflow",
          input: "who is a smart LLM?",
          output: "I am!",
          name: "",
          createdAt: new Date("2026-01-28T00:17:57.458322Z"),
          userMetadata: {
  
          },
          tags: [],
          metrics: {},
          datasetMetadata: {
  
          },
          spans: [
            {
              type: "llm",
              input: [
                {
                  content: "Question: who is a smart LLM?",
                  role: "user",
                },
              ],
              output: {
                content: "I am!",
                role: "user",
              },
              name: "",
              createdAt: new Date("2026-01-28T00:17:57.444313Z"),
              userMetadata: {
  
              },
              tags: [],
              metrics: {},
              datasetMetadata: {
  
              },
              id: "22222222-2222-4222-a222-222222222222",
            },
          ],
        },
      ],
      traceId: "11000011-0000-0000-0000-110000110000",
      parentId: "11000011-0000-0000-0000-110000110000",
    },
  });
  if (res.ok) {
    const { value: result } = res;
    console.log(result);
  } else {
    console.log("traceLogSpansProjectsProjectIdSpansPost failed:", res.error);
  }
}

run();

Parameters

Parameter	Type	Required	Description
request	operations.LogSpansProjectsProjectIdSpansPostRequest	✔️	The request object to use for the request.
security	operations.LogSpansProjectsProjectIdSpansPostSecurity	✔️	The security requirements to use for the request.
options	RequestOptions	➖	Used to set various options for making HTTP requests.
options.fetchOptions	RequestInit	➖	Options that are passed to the underlying HTTP request. This can be used to inject extra headers for examples. All Request options, except method and body, are allowed.
options.retries	RetryConfig	➖	Enables retrying HTTP requests under certain failure conditions.

Response

Promise<models.LogSpansIngestResponse>

Errors

Error Type	Status Code	Content Type
errors.HTTPValidationError	422	application/json
errors.GalileoGeneratedDefaultError	4XX, 5XX	*/*

querySpansProjectsProjectIdSpansSearchPost

Query Spans

Example Usage

import { GalileoGenerated } from "galileo-generated";

const galileoGenerated = new GalileoGenerated();

async function run() {
  const result = await galileoGenerated.trace.querySpansProjectsProjectIdSpansSearchPost({
    apiKeyHeader: process.env["GALILEOGENERATED_API_KEY_HEADER"] ?? "",
  }, {
    projectId: "<value>",
    body: {
      logStreamId: "00000000-0000-0000-0000-000000000000",
      filters: [
        {
          columnId: "<id>",
          operator: "eq",
          value: "example input",
          caseSensitive: true,
          type: "text",
        },
      ],
      sort: {
        columnId: "<id>",
        ascending: false,
      },
    },
  });

  console.log(result);
}

run();

Standalone function

The standalone function version of this method:

import { GalileoGeneratedCore } from "galileo-generated/core.js";
import { traceQuerySpansProjectsProjectIdSpansSearchPost } from "galileo-generated/funcs/traceQuerySpansProjectsProjectIdSpansSearchPost.js";

// Use `GalileoGeneratedCore` for best tree-shaking performance.
// You can create one instance of it to use across an application.
const galileoGenerated = new GalileoGeneratedCore();

async function run() {
  const res = await traceQuerySpansProjectsProjectIdSpansSearchPost(galileoGenerated, {
    apiKeyHeader: process.env["GALILEOGENERATED_API_KEY_HEADER"] ?? "",
  }, {
    projectId: "<value>",
    body: {
      logStreamId: "00000000-0000-0000-0000-000000000000",
      filters: [
        {
          columnId: "<id>",
          operator: "eq",
          value: "example input",
          caseSensitive: true,
          type: "text",
        },
      ],
      sort: {
        columnId: "<id>",
        ascending: false,
      },
    },
  });
  if (res.ok) {
    const { value: result } = res;
    console.log(result);
  } else {
    console.log("traceQuerySpansProjectsProjectIdSpansSearchPost failed:", res.error);
  }
}

run();

Parameters

Parameter	Type	Required	Description
request	operations.QuerySpansProjectsProjectIdSpansSearchPostRequest	✔️	The request object to use for the request.
security	operations.QuerySpansProjectsProjectIdSpansSearchPostSecurity	✔️	The security requirements to use for the request.
options	RequestOptions	➖	Used to set various options for making HTTP requests.
options.fetchOptions	RequestInit	➖	Options that are passed to the underlying HTTP request. This can be used to inject extra headers for examples. All Request options, except method and body, are allowed.
options.retries	RetryConfig	➖	Enables retrying HTTP requests under certain failure conditions.

Response

Promise<models.LogRecordsQueryResponse>

Errors

Error Type	Status Code	Content Type
errors.HTTPValidationError	422	application/json
errors.GalileoGeneratedDefaultError	4XX, 5XX	*/*

queryPartialSpansProjectsProjectIdSpansPartialSearchPost

Query Partial Spans

Example Usage

import { GalileoGenerated } from "galileo-generated";

const galileoGenerated = new GalileoGenerated();

async function run() {
  const result = await galileoGenerated.trace.queryPartialSpansProjectsProjectIdSpansPartialSearchPost({
    apiKeyHeader: process.env["GALILEOGENERATED_API_KEY_HEADER"] ?? "",
  }, {
    projectId: "<value>",
    body: {
      logStreamId: "00000000-0000-0000-0000-000000000000",
      filters: [
        {
          columnId: "<id>",
          operator: "eq",
          value: "example input",
          caseSensitive: true,
          type: "text",
        },
      ],
      sort: {
        columnId: "<id>",
        ascending: false,
      },
      selectColumns: {
        columnIds: [
          "id",
          "metrics/agentic_session_success",
          "metrics/completeness_gpt",
        ],
      },
    },
  });

  console.log(result);
}

run();

Standalone function

The standalone function version of this method:

import { GalileoGeneratedCore } from "galileo-generated/core.js";
import { traceQueryPartialSpansProjectsProjectIdSpansPartialSearchPost } from "galileo-generated/funcs/traceQueryPartialSpansProjectsProjectIdSpansPartialSearchPost.js";

// Use `GalileoGeneratedCore` for best tree-shaking performance.
// You can create one instance of it to use across an application.
const galileoGenerated = new GalileoGeneratedCore();

async function run() {
  const res = await traceQueryPartialSpansProjectsProjectIdSpansPartialSearchPost(galileoGenerated, {
    apiKeyHeader: process.env["GALILEOGENERATED_API_KEY_HEADER"] ?? "",
  }, {
    projectId: "<value>",
    body: {
      logStreamId: "00000000-0000-0000-0000-000000000000",
      filters: [
        {
          columnId: "<id>",
          operator: "eq",
          value: "example input",
          caseSensitive: true,
          type: "text",
        },
      ],
      sort: {
        columnId: "<id>",
        ascending: false,
      },
      selectColumns: {
        columnIds: [
          "id",
          "metrics/agentic_session_success",
          "metrics/completeness_gpt",
        ],
      },
    },
  });
  if (res.ok) {
    const { value: result } = res;
    console.log(result);
  } else {
    console.log("traceQueryPartialSpansProjectsProjectIdSpansPartialSearchPost failed:", res.error);
  }
}

run();

Parameters

Parameter	Type	Required	Description
request	operations.QueryPartialSpansProjectsProjectIdSpansPartialSearchPostRequest	✔️	The request object to use for the request.
security	operations.QueryPartialSpansProjectsProjectIdSpansPartialSearchPostSecurity	✔️	The security requirements to use for the request.
options	RequestOptions	➖	Used to set various options for making HTTP requests.
options.fetchOptions	RequestInit	➖	Options that are passed to the underlying HTTP request. This can be used to inject extra headers for examples. All Request options, except method and body, are allowed.
options.retries	RetryConfig	➖	Enables retrying HTTP requests under certain failure conditions.

Response

Promise<models.LogRecordsPartialQueryResponse>

Errors

Error Type	Status Code	Content Type
errors.HTTPValidationError	422	application/json
errors.GalileoGeneratedDefaultError	4XX, 5XX	*/*

countSpansProjectsProjectIdSpansCountPost

Count Spans

Example Usage

import { GalileoGenerated } from "galileo-generated";

const galileoGenerated = new GalileoGenerated();

async function run() {
  const result = await galileoGenerated.trace.countSpansProjectsProjectIdSpansCountPost({
    apiKeyHeader: process.env["GALILEOGENERATED_API_KEY_HEADER"] ?? "",
  }, {
    projectId: "<value>",
    body: {
      logStreamId: "74aec44e-ec21-4c9f-a3e2-b2ab2b81b4db",
      filters: [
        {
          columnId: "<id>",
          operator: "eq",
          value: "example input",
          caseSensitive: true,
          type: "text",
        },
      ],
    },
  });

  console.log(result);
}

run();

Standalone function

The standalone function version of this method:

import { GalileoGeneratedCore } from "galileo-generated/core.js";
import { traceCountSpansProjectsProjectIdSpansCountPost } from "galileo-generated/funcs/traceCountSpansProjectsProjectIdSpansCountPost.js";

// Use `GalileoGeneratedCore` for best tree-shaking performance.
// You can create one instance of it to use across an application.
const galileoGenerated = new GalileoGeneratedCore();

async function run() {
  const res = await traceCountSpansProjectsProjectIdSpansCountPost(galileoGenerated, {
    apiKeyHeader: process.env["GALILEOGENERATED_API_KEY_HEADER"] ?? "",
  }, {
    projectId: "<value>",
    body: {
      logStreamId: "74aec44e-ec21-4c9f-a3e2-b2ab2b81b4db",
      filters: [
        {
          columnId: "<id>",
          operator: "eq",
          value: "example input",
          caseSensitive: true,
          type: "text",
        },
      ],
    },
  });
  if (res.ok) {
    const { value: result } = res;
    console.log(result);
  } else {
    console.log("traceCountSpansProjectsProjectIdSpansCountPost failed:", res.error);
  }
}

run();

Parameters

Parameter	Type	Required	Description
request	operations.CountSpansProjectsProjectIdSpansCountPostRequest	✔️	The request object to use for the request.
security	operations.CountSpansProjectsProjectIdSpansCountPostSecurity	✔️	The security requirements to use for the request.
options	RequestOptions	➖	Used to set various options for making HTTP requests.
options.fetchOptions	RequestInit	➖	Options that are passed to the underlying HTTP request. This can be used to inject extra headers for examples. All Request options, except method and body, are allowed.
options.retries	RetryConfig	➖	Enables retrying HTTP requests under certain failure conditions.

Response

Promise<models.LogRecordsQueryCountResponse>

Errors

Error Type	Status Code	Content Type
errors.HTTPValidationError	422	application/json
errors.GalileoGeneratedDefaultError	4XX, 5XX	*/*

queryMetricsProjectsProjectIdMetricsSearchPost

Query Metrics

Example Usage

import { GalileoGenerated } from "galileo-generated";

const galileoGenerated = new GalileoGenerated();

async function run() {
  const result = await galileoGenerated.trace.queryMetricsProjectsProjectIdMetricsSearchPost({
    apiKeyHeader: process.env["GALILEOGENERATED_API_KEY_HEADER"] ?? "",
  }, {
    projectId: "<value>",
    body: {
      logStreamId: "00000000-0000-0000-0000-000000000000",
      filters: [
        {
          columnId: "<id>",
          operator: "eq",
          value: "example input",
          caseSensitive: true,
          type: "text",
        },
      ],
      startTime: new Date("2023-10-01T00:00:00Z"),
      endTime: new Date("2023-10-01T01:00:00Z"),
      groupBy: "model",
    },
  });

  console.log(result);
}

run();

Standalone function

The standalone function version of this method:

import { GalileoGeneratedCore } from "galileo-generated/core.js";
import { traceQueryMetricsProjectsProjectIdMetricsSearchPost } from "galileo-generated/funcs/traceQueryMetricsProjectsProjectIdMetricsSearchPost.js";

// Use `GalileoGeneratedCore` for best tree-shaking performance.
// You can create one instance of it to use across an application.
const galileoGenerated = new GalileoGeneratedCore();

async function run() {
  const res = await traceQueryMetricsProjectsProjectIdMetricsSearchPost(galileoGenerated, {
    apiKeyHeader: process.env["GALILEOGENERATED_API_KEY_HEADER"] ?? "",
  }, {
    projectId: "<value>",
    body: {
      logStreamId: "00000000-0000-0000-0000-000000000000",
      filters: [
        {
          columnId: "<id>",
          operator: "eq",
          value: "example input",
          caseSensitive: true,
          type: "text",
        },
      ],
      startTime: new Date("2023-10-01T00:00:00Z"),
      endTime: new Date("2023-10-01T01:00:00Z"),
      groupBy: "model",
    },
  });
  if (res.ok) {
    const { value: result } = res;
    console.log(result);
  } else {
    console.log("traceQueryMetricsProjectsProjectIdMetricsSearchPost failed:", res.error);
  }
}

run();

Parameters

Parameter	Type	Required	Description
request	operations.QueryMetricsProjectsProjectIdMetricsSearchPostRequest	✔️	The request object to use for the request.
security	operations.QueryMetricsProjectsProjectIdMetricsSearchPostSecurity	✔️	The security requirements to use for the request.
options	RequestOptions	➖	Used to set various options for making HTTP requests.
options.fetchOptions	RequestInit	➖	Options that are passed to the underlying HTTP request. This can be used to inject extra headers for examples. All Request options, except method and body, are allowed.
options.retries	RetryConfig	➖	Enables retrying HTTP requests under certain failure conditions.

Response

Promise<models.LogRecordsMetricsResponse>

Errors

Error Type	Status Code	Content Type
errors.HTTPValidationError	422	application/json
errors.GalileoGeneratedDefaultError	4XX, 5XX	*/*

createSessionProjectsProjectIdSessionsPost

Create Session

Example Usage

import { GalileoGenerated } from "galileo-generated";

const galileoGenerated = new GalileoGenerated();

async function run() {
  const result = await galileoGenerated.trace.createSessionProjectsProjectIdSessionsPost({
    apiKeyHeader: process.env["GALILEOGENERATED_API_KEY_HEADER"] ?? "",
  }, {
    projectId: "<value>",
    body: {},
  });

  console.log(result);
}

run();

Standalone function

The standalone function version of this method:

import { GalileoGeneratedCore } from "galileo-generated/core.js";
import { traceCreateSessionProjectsProjectIdSessionsPost } from "galileo-generated/funcs/traceCreateSessionProjectsProjectIdSessionsPost.js";

// Use `GalileoGeneratedCore` for best tree-shaking performance.
// You can create one instance of it to use across an application.
const galileoGenerated = new GalileoGeneratedCore();

async function run() {
  const res = await traceCreateSessionProjectsProjectIdSessionsPost(galileoGenerated, {
    apiKeyHeader: process.env["GALILEOGENERATED_API_KEY_HEADER"] ?? "",
  }, {
    projectId: "<value>",
    body: {},
  });
  if (res.ok) {
    const { value: result } = res;
    console.log(result);
  } else {
    console.log("traceCreateSessionProjectsProjectIdSessionsPost failed:", res.error);
  }
}

run();

Parameters

Parameter	Type	Required	Description
request	operations.CreateSessionProjectsProjectIdSessionsPostRequest	✔️	The request object to use for the request.
security	operations.CreateSessionProjectsProjectIdSessionsPostSecurity	✔️	The security requirements to use for the request.
options	RequestOptions	➖	Used to set various options for making HTTP requests.
options.fetchOptions	RequestInit	➖	Options that are passed to the underlying HTTP request. This can be used to inject extra headers for examples. All Request options, except method and body, are allowed.
options.retries	RetryConfig	➖	Enables retrying HTTP requests under certain failure conditions.

Response

Promise<models.SessionCreateResponse>

Errors

Error Type	Status Code	Content Type
errors.HTTPValidationError	422	application/json
errors.GalileoGeneratedDefaultError	4XX, 5XX	*/*

querySessionsProjectsProjectIdSessionsSearchPost

Query Sessions

Example Usage

import { GalileoGenerated } from "galileo-generated";

const galileoGenerated = new GalileoGenerated();

async function run() {
  const result = await galileoGenerated.trace.querySessionsProjectsProjectIdSessionsSearchPost({
    apiKeyHeader: process.env["GALILEOGENERATED_API_KEY_HEADER"] ?? "",
  }, {
    projectId: "<value>",
    body: {
      logStreamId: "00000000-0000-0000-0000-000000000000",
      filters: [
        {
          columnId: "<id>",
          operator: "eq",
          value: "example input",
          caseSensitive: true,
          type: "text",
        },
      ],
      sort: {
        columnId: "<id>",
        ascending: false,
      },
    },
  });

  console.log(result);
}

run();

Standalone function

The standalone function version of this method:

import { GalileoGeneratedCore } from "galileo-generated/core.js";
import { traceQuerySessionsProjectsProjectIdSessionsSearchPost } from "galileo-generated/funcs/traceQuerySessionsProjectsProjectIdSessionsSearchPost.js";

// Use `GalileoGeneratedCore` for best tree-shaking performance.
// You can create one instance of it to use across an application.
const galileoGenerated = new GalileoGeneratedCore();

async function run() {
  const res = await traceQuerySessionsProjectsProjectIdSessionsSearchPost(galileoGenerated, {
    apiKeyHeader: process.env["GALILEOGENERATED_API_KEY_HEADER"] ?? "",
  }, {
    projectId: "<value>",
    body: {
      logStreamId: "00000000-0000-0000-0000-000000000000",
      filters: [
        {
          columnId: "<id>",
          operator: "eq",
          value: "example input",
          caseSensitive: true,
          type: "text",
        },
      ],
      sort: {
        columnId: "<id>",
        ascending: false,
      },
    },
  });
  if (res.ok) {
    const { value: result } = res;
    console.log(result);
  } else {
    console.log("traceQuerySessionsProjectsProjectIdSessionsSearchPost failed:", res.error);
  }
}

run();

Parameters

Parameter	Type	Required	Description
request	operations.QuerySessionsProjectsProjectIdSessionsSearchPostRequest	✔️	The request object to use for the request.
security	operations.QuerySessionsProjectsProjectIdSessionsSearchPostSecurity	✔️	The security requirements to use for the request.
options	RequestOptions	➖	Used to set various options for making HTTP requests.
options.fetchOptions	RequestInit	➖	Options that are passed to the underlying HTTP request. This can be used to inject extra headers for examples. All Request options, except method and body, are allowed.
options.retries	RetryConfig	➖	Enables retrying HTTP requests under certain failure conditions.

Response

Promise<models.LogRecordsQueryResponse>

Errors

Error Type	Status Code	Content Type
errors.HTTPValidationError	422	application/json
errors.GalileoGeneratedDefaultError	4XX, 5XX	*/*

queryPartialSessionsProjectsProjectIdSessionsPartialSearchPost

Query Partial Sessions

Example Usage

import { GalileoGenerated } from "galileo-generated";

const galileoGenerated = new GalileoGenerated();

async function run() {
  const result = await galileoGenerated.trace.queryPartialSessionsProjectsProjectIdSessionsPartialSearchPost({
    apiKeyHeader: process.env["GALILEOGENERATED_API_KEY_HEADER"] ?? "",
  }, {
    projectId: "<value>",
    body: {
      logStreamId: "00000000-0000-0000-0000-000000000000",
      filters: [
        {
          columnId: "<id>",
          operator: "eq",
          value: "example input",
          caseSensitive: true,
          type: "text",
        },
      ],
      sort: {
        columnId: "<id>",
        ascending: false,
      },
      selectColumns: {
        columnIds: [
          "id",
          "metrics/agentic_session_success",
          "metrics/completeness_gpt",
        ],
      },
    },
  });

  console.log(result);
}

run();

Standalone function

The standalone function version of this method:

import { GalileoGeneratedCore } from "galileo-generated/core.js";
import { traceQueryPartialSessionsProjectsProjectIdSessionsPartialSearchPost } from "galileo-generated/funcs/traceQueryPartialSessionsProjectsProjectIdSessionsPartialSearchPost.js";

// Use `GalileoGeneratedCore` for best tree-shaking performance.
// You can create one instance of it to use across an application.
const galileoGenerated = new GalileoGeneratedCore();

async function run() {
  const res = await traceQueryPartialSessionsProjectsProjectIdSessionsPartialSearchPost(galileoGenerated, {
    apiKeyHeader: process.env["GALILEOGENERATED_API_KEY_HEADER"] ?? "",
  }, {
    projectId: "<value>",
    body: {
      logStreamId: "00000000-0000-0000-0000-000000000000",
      filters: [
        {
          columnId: "<id>",
          operator: "eq",
          value: "example input",
          caseSensitive: true,
          type: "text",
        },
      ],
      sort: {
        columnId: "<id>",
        ascending: false,
      },
      selectColumns: {
        columnIds: [
          "id",
          "metrics/agentic_session_success",
          "metrics/completeness_gpt",
        ],
      },
    },
  });
  if (res.ok) {
    const { value: result } = res;
    console.log(result);
  } else {
    console.log("traceQueryPartialSessionsProjectsProjectIdSessionsPartialSearchPost failed:", res.error);
  }
}

run();

Parameters

Parameter	Type	Required	Description
request	operations.QueryPartialSessionsProjectsProjectIdSessionsPartialSearchPostRequest	✔️	The request object to use for the request.
security	operations.QueryPartialSessionsProjectsProjectIdSessionsPartialSearchPostSecurity	✔️	The security requirements to use for the request.
options	RequestOptions	➖	Used to set various options for making HTTP requests.
options.fetchOptions	RequestInit	➖	Options that are passed to the underlying HTTP request. This can be used to inject extra headers for examples. All Request options, except method and body, are allowed.
options.retries	RetryConfig	➖	Enables retrying HTTP requests under certain failure conditions.

Response

Promise<models.LogRecordsPartialQueryResponse>

Errors

Error Type	Status Code	Content Type
errors.HTTPValidationError	422	application/json
errors.GalileoGeneratedDefaultError	4XX, 5XX	*/*

countSessionsProjectsProjectIdSessionsCountPost

Count Sessions

Example Usage

import { GalileoGenerated } from "galileo-generated";

const galileoGenerated = new GalileoGenerated();

async function run() {
  const result = await galileoGenerated.trace.countSessionsProjectsProjectIdSessionsCountPost({
    apiKeyHeader: process.env["GALILEOGENERATED_API_KEY_HEADER"] ?? "",
  }, {
    projectId: "<value>",
    body: {
      logStreamId: "74aec44e-ec21-4c9f-a3e2-b2ab2b81b4db",
      filters: [
        {
          columnId: "<id>",
          operator: "eq",
          value: "example input",
          caseSensitive: true,
          type: "text",
        },
      ],
    },
  });

  console.log(result);
}

run();

Standalone function

The standalone function version of this method:

import { GalileoGeneratedCore } from "galileo-generated/core.js";
import { traceCountSessionsProjectsProjectIdSessionsCountPost } from "galileo-generated/funcs/traceCountSessionsProjectsProjectIdSessionsCountPost.js";

// Use `GalileoGeneratedCore` for best tree-shaking performance.
// You can create one instance of it to use across an application.
const galileoGenerated = new GalileoGeneratedCore();

async function run() {
  const res = await traceCountSessionsProjectsProjectIdSessionsCountPost(galileoGenerated, {
    apiKeyHeader: process.env["GALILEOGENERATED_API_KEY_HEADER"] ?? "",
  }, {
    projectId: "<value>",
    body: {
      logStreamId: "74aec44e-ec21-4c9f-a3e2-b2ab2b81b4db",
      filters: [
        {
          columnId: "<id>",
          operator: "eq",
          value: "example input",
          caseSensitive: true,
          type: "text",
        },
      ],
    },
  });
  if (res.ok) {
    const { value: result } = res;
    console.log(result);
  } else {
    console.log("traceCountSessionsProjectsProjectIdSessionsCountPost failed:", res.error);
  }
}

run();

Parameters

Parameter	Type	Required	Description
request	operations.CountSessionsProjectsProjectIdSessionsCountPostRequest	✔️	The request object to use for the request.
security	operations.CountSessionsProjectsProjectIdSessionsCountPostSecurity	✔️	The security requirements to use for the request.
options	RequestOptions	➖	Used to set various options for making HTTP requests.
options.fetchOptions	RequestInit	➖	Options that are passed to the underlying HTTP request. This can be used to inject extra headers for examples. All Request options, except method and body, are allowed.
options.retries	RetryConfig	➖	Enables retrying HTTP requests under certain failure conditions.

Response

Promise<models.LogRecordsQueryCountResponse>

Errors

Error Type	Status Code	Content Type
errors.HTTPValidationError	422	application/json
errors.GalileoGeneratedDefaultError	4XX, 5XX	*/*

getSessionProjectsProjectIdSessionsSessionIdGet

Get Session

Example Usage

import { GalileoGenerated } from "galileo-generated";

const galileoGenerated = new GalileoGenerated();

async function run() {
  const result = await galileoGenerated.trace.getSessionProjectsProjectIdSessionsSessionIdGet({
    apiKeyHeader: process.env["GALILEOGENERATED_API_KEY_HEADER"] ?? "",
  }, {
    sessionId: "<value>",
    projectId: "<value>",
  });

  console.log(result);
}

run();

Standalone function

The standalone function version of this method:

import { GalileoGeneratedCore } from "galileo-generated/core.js";
import { traceGetSessionProjectsProjectIdSessionsSessionIdGet } from "galileo-generated/funcs/traceGetSessionProjectsProjectIdSessionsSessionIdGet.js";

// Use `GalileoGeneratedCore` for best tree-shaking performance.
// You can create one instance of it to use across an application.
const galileoGenerated = new GalileoGeneratedCore();

async function run() {
  const res = await traceGetSessionProjectsProjectIdSessionsSessionIdGet(galileoGenerated, {
    apiKeyHeader: process.env["GALILEOGENERATED_API_KEY_HEADER"] ?? "",
  }, {
    sessionId: "<value>",
    projectId: "<value>",
  });
  if (res.ok) {
    const { value: result } = res;
    console.log(result);
  } else {
    console.log("traceGetSessionProjectsProjectIdSessionsSessionIdGet failed:", res.error);
  }
}

run();

Parameters

Parameter	Type	Required	Description
request	operations.GetSessionProjectsProjectIdSessionsSessionIdGetRequest	✔️	The request object to use for the request.
security	operations.GetSessionProjectsProjectIdSessionsSessionIdGetSecurity	✔️	The security requirements to use for the request.
options	RequestOptions	➖	Used to set various options for making HTTP requests.
options.fetchOptions	RequestInit	➖	Options that are passed to the underlying HTTP request. This can be used to inject extra headers for examples. All Request options, except method and body, are allowed.
options.retries	RetryConfig	➖	Enables retrying HTTP requests under certain failure conditions.

Response

Promise<models.ExtendedSessionRecordWithChildren>

Errors

Error Type	Status Code	Content Type
errors.HTTPValidationError	422	application/json
errors.GalileoGeneratedDefaultError	4XX, 5XX	*/*

sessionsAvailableColumnsProjectsProjectIdSessionsAvailableColumnsPost

Sessions Available Columns

Example Usage

import { GalileoGenerated } from "galileo-generated";

const galileoGenerated = new GalileoGenerated();

async function run() {
  const result = await galileoGenerated.trace.sessionsAvailableColumnsProjectsProjectIdSessionsAvailableColumnsPost({
    apiKeyHeader: process.env["GALILEOGENERATED_API_KEY_HEADER"] ?? "",
  }, {
    projectId: "<value>",
    body: {
      logStreamId: "00000000-0000-0000-0000-000000000000",
    },
  });

  console.log(result);
}

run();

Standalone function

The standalone function version of this method:

import { GalileoGeneratedCore } from "galileo-generated/core.js";
import { traceSessionsAvailableColumnsProjectsProjectIdSessionsAvailableColumnsPost } from "galileo-generated/funcs/traceSessionsAvailableColumnsProjectsProjectIdSessionsAvailableColumnsPost.js";

// Use `GalileoGeneratedCore` for best tree-shaking performance.
// You can create one instance of it to use across an application.
const galileoGenerated = new GalileoGeneratedCore();

async function run() {
  const res = await traceSessionsAvailableColumnsProjectsProjectIdSessionsAvailableColumnsPost(galileoGenerated, {
    apiKeyHeader: process.env["GALILEOGENERATED_API_KEY_HEADER"] ?? "",
  }, {
    projectId: "<value>",
    body: {
      logStreamId: "00000000-0000-0000-0000-000000000000",
    },
  });
  if (res.ok) {
    const { value: result } = res;
    console.log(result);
  } else {
    console.log("traceSessionsAvailableColumnsProjectsProjectIdSessionsAvailableColumnsPost failed:", res.error);
  }
}

run();

Parameters

Parameter	Type	Required	Description
request	operations.SessionsAvailableColumnsProjectsProjectIdSessionsAvailableColumnsPostRequest	✔️	The request object to use for the request.
security	operations.SessionsAvailableColumnsProjectsProjectIdSessionsAvailableColumnsPostSecurity	✔️	The security requirements to use for the request.
options	RequestOptions	➖	Used to set various options for making HTTP requests.
options.fetchOptions	RequestInit	➖	Options that are passed to the underlying HTTP request. This can be used to inject extra headers for examples. All Request options, except method and body, are allowed.
options.retries	RetryConfig	➖	Enables retrying HTTP requests under certain failure conditions.

Response

Promise<models.LogRecordsAvailableColumnsResponse>

Errors

Error Type	Status Code	Content Type
errors.HTTPValidationError	422	application/json
errors.GalileoGeneratedDefaultError	4XX, 5XX	*/*

getAggregatedTraceViewProjectsProjectIdTracesAggregatedPost

Get Aggregated Trace View

Example Usage

import { GalileoGenerated } from "galileo-generated";

const galileoGenerated = new GalileoGenerated();

async function run() {
  const result = await galileoGenerated.trace.getAggregatedTraceViewProjectsProjectIdTracesAggregatedPost({
    apiKeyHeader: process.env["GALILEOGENERATED_API_KEY_HEADER"] ?? "",
  }, {
    projectId: "<value>",
    body: {
      logStreamId: "<value>",
    },
  });

  console.log(result);
}

run();

Standalone function

The standalone function version of this method:

import { GalileoGeneratedCore } from "galileo-generated/core.js";
import { traceGetAggregatedTraceViewProjectsProjectIdTracesAggregatedPost } from "galileo-generated/funcs/traceGetAggregatedTraceViewProjectsProjectIdTracesAggregatedPost.js";

// Use `GalileoGeneratedCore` for best tree-shaking performance.
// You can create one instance of it to use across an application.
const galileoGenerated = new GalileoGeneratedCore();

async function run() {
  const res = await traceGetAggregatedTraceViewProjectsProjectIdTracesAggregatedPost(galileoGenerated, {
    apiKeyHeader: process.env["GALILEOGENERATED_API_KEY_HEADER"] ?? "",
  }, {
    projectId: "<value>",
    body: {
      logStreamId: "<value>",
    },
  });
  if (res.ok) {
    const { value: result } = res;
    console.log(result);
  } else {
    console.log("traceGetAggregatedTraceViewProjectsProjectIdTracesAggregatedPost failed:", res.error);
  }
}

run();

Parameters

Parameter	Type	Required	Description
request	operations.GetAggregatedTraceViewProjectsProjectIdTracesAggregatedPostRequest	✔️	The request object to use for the request.
security	operations.GetAggregatedTraceViewProjectsProjectIdTracesAggregatedPostSecurity	✔️	The security requirements to use for the request.
options	RequestOptions	➖	Used to set various options for making HTTP requests.
options.fetchOptions	RequestInit	➖	Options that are passed to the underlying HTTP request. This can be used to inject extra headers for examples. All Request options, except method and body, are allowed.
options.retries	RetryConfig	➖	Enables retrying HTTP requests under certain failure conditions.

Response

Promise<models.AggregatedTraceViewResponse>

Errors

Error Type	Status Code	Content Type
errors.HTTPValidationError	422	application/json
errors.GalileoGeneratedDefaultError	4XX, 5XX	*/*

exportRecordsProjectsProjectIdExportRecordsPost

Export Records

Example Usage

import { GalileoGenerated } from "galileo-generated";

const galileoGenerated = new GalileoGenerated();

async function run() {
  const result = await galileoGenerated.trace.exportRecordsProjectsProjectIdExportRecordsPost({
    apiKeyHeader: process.env["GALILEOGENERATED_API_KEY_HEADER"] ?? "",
  }, {
    projectId: "<value>",
    body: {
      logStreamId: "00000000-0000-0000-0000-000000000000",
      filters: [
        {
          columnId: "<id>",
          operator: "eq",
          value: "example input",
          caseSensitive: true,
          type: "text",
        },
      ],
      sort: {
        columnId: "<id>",
        ascending: false,
      },
      columnIds: [
        "input",
        "output",
        "created_at",
      ],
      exportFormat: "jsonl",
      rootType: "trace",
    },
  });

  console.log(result);
}

run();

Standalone function

The standalone function version of this method:

import { GalileoGeneratedCore } from "galileo-generated/core.js";
import { traceExportRecordsProjectsProjectIdExportRecordsPost } from "galileo-generated/funcs/traceExportRecordsProjectsProjectIdExportRecordsPost.js";

// Use `GalileoGeneratedCore` for best tree-shaking performance.
// You can create one instance of it to use across an application.
const galileoGenerated = new GalileoGeneratedCore();

async function run() {
  const res = await traceExportRecordsProjectsProjectIdExportRecordsPost(galileoGenerated, {
    apiKeyHeader: process.env["GALILEOGENERATED_API_KEY_HEADER"] ?? "",
  }, {
    projectId: "<value>",
    body: {
      logStreamId: "00000000-0000-0000-0000-000000000000",
      filters: [
        {
          columnId: "<id>",
          operator: "eq",
          value: "example input",
          caseSensitive: true,
          type: "text",
        },
      ],
      sort: {
        columnId: "<id>",
        ascending: false,
      },
      columnIds: [
        "input",
        "output",
        "created_at",
      ],
      exportFormat: "jsonl",
      rootType: "trace",
    },
  });
  if (res.ok) {
    const { value: result } = res;
    console.log(result);
  } else {
    console.log("traceExportRecordsProjectsProjectIdExportRecordsPost failed:", res.error);
  }
}

run();

Parameters

Parameter	Type	Required	Description
request	operations.ExportRecordsProjectsProjectIdExportRecordsPostRequest	✔️	The request object to use for the request.
security	operations.ExportRecordsProjectsProjectIdExportRecordsPostSecurity	✔️	The security requirements to use for the request.
options	RequestOptions	➖	Used to set various options for making HTTP requests.
options.fetchOptions	RequestInit	➖	Options that are passed to the underlying HTTP request. This can be used to inject extra headers for examples. All Request options, except method and body, are allowed.
options.retries	RetryConfig	➖	Enables retrying HTTP requests under certain failure conditions.

Response

Promise<any>

Errors

Error Type	Status Code	Content Type
errors.HTTPValidationError	422	application/json
errors.GalileoGeneratedDefaultError	4XX, 5XX	*/*

recomputeMetricsProjectsProjectIdRecomputeMetricsPost

Recompute Metrics

Example Usage

import { GalileoGenerated } from "galileo-generated";

const galileoGenerated = new GalileoGenerated();

async function run() {
  const result = await galileoGenerated.trace.recomputeMetricsProjectsProjectIdRecomputeMetricsPost({
    apiKeyHeader: process.env["GALILEOGENERATED_API_KEY_HEADER"] ?? "",
  }, {
    projectId: "<value>",
    body: {
      logStreamId: "00000000-0000-0000-0000-000000000000",
      filters: [
        {
          columnId: "<id>",
          operator: "eq",
          value: "example input",
          caseSensitive: true,
          type: "text",
        },
      ],
      sort: {
        columnId: "<id>",
        ascending: false,
      },
      scorerIds: [
        "<value 1>",
        "<value 2>",
        "<value 3>",
      ],
    },
  });

  console.log(result);
}

run();

Standalone function

The standalone function version of this method:

import { GalileoGeneratedCore } from "galileo-generated/core.js";
import { traceRecomputeMetricsProjectsProjectIdRecomputeMetricsPost } from "galileo-generated/funcs/traceRecomputeMetricsProjectsProjectIdRecomputeMetricsPost.js";

// Use `GalileoGeneratedCore` for best tree-shaking performance.
// You can create one instance of it to use across an application.
const galileoGenerated = new GalileoGeneratedCore();

async function run() {
  const res = await traceRecomputeMetricsProjectsProjectIdRecomputeMetricsPost(galileoGenerated, {
    apiKeyHeader: process.env["GALILEOGENERATED_API_KEY_HEADER"] ?? "",
  }, {
    projectId: "<value>",
    body: {
      logStreamId: "00000000-0000-0000-0000-000000000000",
      filters: [
        {
          columnId: "<id>",
          operator: "eq",
          value: "example input",
          caseSensitive: true,
          type: "text",
        },
      ],
      sort: {
        columnId: "<id>",
        ascending: false,
      },
      scorerIds: [
        "<value 1>",
        "<value 2>",
        "<value 3>",
      ],
    },
  });
  if (res.ok) {
    const { value: result } = res;
    console.log(result);
  } else {
    console.log("traceRecomputeMetricsProjectsProjectIdRecomputeMetricsPost failed:", res.error);
  }
}

run();

Parameters

Parameter	Type	Required	Description
request	operations.RecomputeMetricsProjectsProjectIdRecomputeMetricsPostRequest	✔️	The request object to use for the request.
security	operations.RecomputeMetricsProjectsProjectIdRecomputeMetricsPostSecurity	✔️	The security requirements to use for the request.
options	RequestOptions	➖	Used to set various options for making HTTP requests.
options.fetchOptions	RequestInit	➖	Options that are passed to the underlying HTTP request. This can be used to inject extra headers for examples. All Request options, except method and body, are allowed.
options.retries	RetryConfig	➖	Enables retrying HTTP requests under certain failure conditions.

Response

Promise<any>

Errors

Error Type	Status Code	Content Type
errors.HTTPValidationError	422	application/json
errors.GalileoGeneratedDefaultError	4XX, 5XX	*/*

deleteTracesProjectsProjectIdTracesDeletePost

Delete all trace records that match the provided filters.

Example Usage

import { GalileoGenerated } from "galileo-generated";

const galileoGenerated = new GalileoGenerated();

async function run() {
  const result = await galileoGenerated.trace.deleteTracesProjectsProjectIdTracesDeletePost({
    apiKeyHeader: process.env["GALILEOGENERATED_API_KEY_HEADER"] ?? "",
  }, {
    projectId: "<value>",
    body: {
      logStreamId: "74aec44e-ec21-4c9f-a3e2-b2ab2b81b4db",
      filters: [
        {
          columnId: "<id>",
          operator: "eq",
          value: "example input",
          caseSensitive: true,
          type: "text",
        },
      ],
    },
  });

  console.log(result);
}

run();

Standalone function

The standalone function version of this method:

import { GalileoGeneratedCore } from "galileo-generated/core.js";
import { traceDeleteTracesProjectsProjectIdTracesDeletePost } from "galileo-generated/funcs/traceDeleteTracesProjectsProjectIdTracesDeletePost.js";

// Use `GalileoGeneratedCore` for best tree-shaking performance.
// You can create one instance of it to use across an application.
const galileoGenerated = new GalileoGeneratedCore();

async function run() {
  const res = await traceDeleteTracesProjectsProjectIdTracesDeletePost(galileoGenerated, {
    apiKeyHeader: process.env["GALILEOGENERATED_API_KEY_HEADER"] ?? "",
  }, {
    projectId: "<value>",
    body: {
      logStreamId: "74aec44e-ec21-4c9f-a3e2-b2ab2b81b4db",
      filters: [
        {
          columnId: "<id>",
          operator: "eq",
          value: "example input",
          caseSensitive: true,
          type: "text",
        },
      ],
    },
  });
  if (res.ok) {
    const { value: result } = res;
    console.log(result);
  } else {
    console.log("traceDeleteTracesProjectsProjectIdTracesDeletePost failed:", res.error);
  }
}

run();

Parameters

Parameter	Type	Required	Description
request	operations.DeleteTracesProjectsProjectIdTracesDeletePostRequest	✔️	The request object to use for the request.
security	operations.DeleteTracesProjectsProjectIdTracesDeletePostSecurity	✔️	The security requirements to use for the request.
options	RequestOptions	➖	Used to set various options for making HTTP requests.
options.fetchOptions	RequestInit	➖	Options that are passed to the underlying HTTP request. This can be used to inject extra headers for examples. All Request options, except method and body, are allowed.
options.retries	RetryConfig	➖	Enables retrying HTTP requests under certain failure conditions.

Response

Promise<models.LogRecordsDeleteResponse>

Errors

Error Type	Status Code	Content Type
errors.HTTPValidationError	422	application/json
errors.GalileoGeneratedDefaultError	4XX, 5XX	*/*

deleteSpansProjectsProjectIdSpansDeletePost

Delete all span records that match the provided filters.

Example Usage

import { GalileoGenerated } from "galileo-generated";

const galileoGenerated = new GalileoGenerated();

async function run() {
  const result = await galileoGenerated.trace.deleteSpansProjectsProjectIdSpansDeletePost({
    apiKeyHeader: process.env["GALILEOGENERATED_API_KEY_HEADER"] ?? "",
  }, {
    projectId: "<value>",
    body: {
      logStreamId: "74aec44e-ec21-4c9f-a3e2-b2ab2b81b4db",
      filters: [
        {
          columnId: "<id>",
          operator: "eq",
          value: "example input",
          caseSensitive: true,
          type: "text",
        },
      ],
    },
  });

  console.log(result);
}

run();

Standalone function

The standalone function version of this method:

import { GalileoGeneratedCore } from "galileo-generated/core.js";
import { traceDeleteSpansProjectsProjectIdSpansDeletePost } from "galileo-generated/funcs/traceDeleteSpansProjectsProjectIdSpansDeletePost.js";

// Use `GalileoGeneratedCore` for best tree-shaking performance.
// You can create one instance of it to use across an application.
const galileoGenerated = new GalileoGeneratedCore();

async function run() {
  const res = await traceDeleteSpansProjectsProjectIdSpansDeletePost(galileoGenerated, {
    apiKeyHeader: process.env["GALILEOGENERATED_API_KEY_HEADER"] ?? "",
  }, {
    projectId: "<value>",
    body: {
      logStreamId: "74aec44e-ec21-4c9f-a3e2-b2ab2b81b4db",
      filters: [
        {
          columnId: "<id>",
          operator: "eq",
          value: "example input",
          caseSensitive: true,
          type: "text",
        },
      ],
    },
  });
  if (res.ok) {
    const { value: result } = res;
    console.log(result);
  } else {
    console.log("traceDeleteSpansProjectsProjectIdSpansDeletePost failed:", res.error);
  }
}

run();

Parameters

Parameter	Type	Required	Description
request	operations.DeleteSpansProjectsProjectIdSpansDeletePostRequest	✔️	The request object to use for the request.
security	operations.DeleteSpansProjectsProjectIdSpansDeletePostSecurity	✔️	The security requirements to use for the request.
options	RequestOptions	➖	Used to set various options for making HTTP requests.
options.fetchOptions	RequestInit	➖	Options that are passed to the underlying HTTP request. This can be used to inject extra headers for examples. All Request options, except method and body, are allowed.
options.retries	RetryConfig	➖	Enables retrying HTTP requests under certain failure conditions.

Response

Promise<models.LogRecordsDeleteResponse>

Errors

Error Type	Status Code	Content Type
errors.HTTPValidationError	422	application/json
errors.GalileoGeneratedDefaultError	4XX, 5XX	*/*

deleteSessionsProjectsProjectIdSessionsDeletePost

Delete all session records that match the provided filters.

Example Usage

import { GalileoGenerated } from "galileo-generated";

const galileoGenerated = new GalileoGenerated();

async function run() {
  const result = await galileoGenerated.trace.deleteSessionsProjectsProjectIdSessionsDeletePost({
    apiKeyHeader: process.env["GALILEOGENERATED_API_KEY_HEADER"] ?? "",
  }, {
    projectId: "<value>",
    body: {
      logStreamId: "74aec44e-ec21-4c9f-a3e2-b2ab2b81b4db",
      filters: [
        {
          columnId: "<id>",
          operator: "eq",
          value: "example input",
          caseSensitive: true,
          type: "text",
        },
      ],
    },
  });

  console.log(result);
}

run();

Standalone function

The standalone function version of this method:

import { GalileoGeneratedCore } from "galileo-generated/core.js";
import { traceDeleteSessionsProjectsProjectIdSessionsDeletePost } from "galileo-generated/funcs/traceDeleteSessionsProjectsProjectIdSessionsDeletePost.js";

// Use `GalileoGeneratedCore` for best tree-shaking performance.
// You can create one instance of it to use across an application.
const galileoGenerated = new GalileoGeneratedCore();

async function run() {
  const res = await traceDeleteSessionsProjectsProjectIdSessionsDeletePost(galileoGenerated, {
    apiKeyHeader: process.env["GALILEOGENERATED_API_KEY_HEADER"] ?? "",
  }, {
    projectId: "<value>",
    body: {
      logStreamId: "74aec44e-ec21-4c9f-a3e2-b2ab2b81b4db",
      filters: [
        {
          columnId: "<id>",
          operator: "eq",
          value: "example input",
          caseSensitive: true,
          type: "text",
        },
      ],
    },
  });
  if (res.ok) {
    const { value: result } = res;
    console.log(result);
  } else {
    console.log("traceDeleteSessionsProjectsProjectIdSessionsDeletePost failed:", res.error);
  }
}

run();

Parameters

Parameter	Type	Required	Description
request	operations.DeleteSessionsProjectsProjectIdSessionsDeletePostRequest	✔️	The request object to use for the request.
security	operations.DeleteSessionsProjectsProjectIdSessionsDeletePostSecurity	✔️	The security requirements to use for the request.
options	RequestOptions	➖	Used to set various options for making HTTP requests.
options.fetchOptions	RequestInit	➖	Options that are passed to the underlying HTTP request. This can be used to inject extra headers for examples. All Request options, except method and body, are allowed.
options.retries	RetryConfig	➖	Enables retrying HTTP requests under certain failure conditions.

Response

Promise<models.LogRecordsDeleteResponse>

Errors

Error Type	Status Code	Content Type
errors.HTTPValidationError	422	application/json
errors.GalileoGeneratedDefaultError	4XX, 5XX	*/*