Migrate run retrieval to SmithDB

import { Client } from "langsmith";

const client = new Client();
const project = await client.readProject({ projectName: "default" });
let runId = "<run-id>";
let startTime = "2026-06-01T12:00:00Z"; // Optional, but speeds up retrieval
await client.runs.retrieve(runId, {
  project_id: project.id,
  start_time: startTime,
});

import java.time.OffsetDateTime

import com.langchain.smith.client.LangsmithClient
import com.langchain.smith.client.okhttp.LangsmithOkHttpClient
import com.langchain.smith.models.runs.RunRetrieveV2Params
import com.langchain.smith.models.sessions.SessionListParams

val client: LangsmithClient = LangsmithOkHttpClient.fromEnv()

val project = client.sessions().list(
    SessionListParams.builder().name("default").limit(1L).build()
).items().first()

var runId = "<run-id>"
var startTime = "<run-start-time-rfc3339>" // Optional, but speeds up retrieval
client.runs().retrieveV2(
    runId,
    RunRetrieveV2Params.builder()
        .projectId(project.id())
        .startTime(OffsetDateTime.parse(startTime))
        .build()
)

package main

import (
	"context"
	"time"

	"github.com/langchain-ai/langsmith-go"
)

ctx := context.Background()
client := langsmith.NewClient()

runID := "<run-id>"
startTime := time.Date(2026, 6, 1, 12, 0, 0, 0, time.UTC) // Optional, but speeds up retrieval
projectID := "<project-id>"
run, err := client.Runs.GetV2(ctx, runID, langsmith.RunGetV2Params{
	ProjectID: langsmith.F(projectID),
	StartTime: langsmith.F(startTime),
})

import { Client } from "langsmith";

const client = new Client();
let runId = "<run-id>";
let startTime = "2026-06-01T12:00:00Z";
let projectId = "<project-id>";
const retrievedRun = await client.runs.retrieve(runId, {
  project_id: projectId,
  start_time: startTime,
  selects: ["NAME", "STATUS", "TOTAL_TOKENS"],
});
console.log(retrievedRun.name, retrievedRun.status, retrievedRun.total_tokens);

import java.time.OffsetDateTime

import com.langchain.smith.client.LangsmithClient
import com.langchain.smith.client.okhttp.LangsmithOkHttpClient
import com.langchain.smith.models.runs.RunRetrieveV2Params
import com.langchain.smith.models.sessions.SessionListParams

val client: LangsmithClient = LangsmithOkHttpClient.fromEnv()

val project = client.sessions().list(
    SessionListParams.builder().name("default").limit(1L).build()
).items().first()

var runId = "<run-id>"
var startTime = "<run-start-time-rfc3339>"
val run = client.runs().retrieveV2(
    runId,
    RunRetrieveV2Params.builder()
        .projectId(project.id())
        .startTime(OffsetDateTime.parse(startTime))
        .addSelect(RunRetrieveV2Params.Select.NAME)
        .addSelect(RunRetrieveV2Params.Select.STATUS)
        .addSelect(RunRetrieveV2Params.Select.TOTAL_TOKENS)
        .build()
)
println("${run.name()} ${run.status()} ${run.totalTokens()}")

package main

import (
	"context"
	"fmt"
	"time"

	"github.com/langchain-ai/langsmith-go"
)

ctx := context.Background()
client := langsmith.NewClient()

runID := "<run-id>"
startTime := time.Date(2026, 6, 1, 12, 0, 0, 0, time.UTC)
projectID := "<project-id>"
run, err := client.Runs.GetV2(ctx, runID, langsmith.RunGetV2Params{
	ProjectID: langsmith.F(projectID),
	StartTime: langsmith.F(startTime),
	Selects: langsmith.F([]langsmith.RunGetV2ParamsSelect{
		langsmith.RunGetV2ParamsSelectName,
		langsmith.RunGetV2ParamsSelectStatus,
		langsmith.RunGetV2ParamsSelectTotalTokens,
	}),
})
fmt.Println(run.Name, run.Status, run.TotalTokens)

import { Client, NotFoundError } from "langsmith";

const client = new Client();
const project = await client.readProject({ projectName: "default" });
let runId = "<run-id>";
const startTime = "2026-06-01T12:00:00Z";

try {
  await client.runs.retrieve(runId, {
    project_id: project.id,
    start_time: startTime,
  });
} catch (e) {
  if (e instanceof NotFoundError) {
    console.log(`Run ${runId} not found`);
  }
}

import java.time.OffsetDateTime

import com.langchain.smith.client.LangsmithClient
import com.langchain.smith.client.okhttp.LangsmithOkHttpClient
import com.langchain.smith.errors.NotFoundException
import com.langchain.smith.models.runs.RunRetrieveV2Params
import com.langchain.smith.models.sessions.SessionListParams

val client: LangsmithClient = LangsmithOkHttpClient.fromEnv()

val project = client.sessions().list(
    SessionListParams.builder().name("default").limit(1L).build()
).items().first()

var runId = "<run-id>"
var startTime = "<run-start-time-rfc3339>"
try {
    client.runs().retrieveV2(
        runId,
        RunRetrieveV2Params.builder()
            .projectId(project.id())
            .startTime(OffsetDateTime.parse(startTime))
            .build()
    )
} catch (e: NotFoundException) {
    println("Run $runId not found")
}

package main

import (
	"context"
	"errors"
	"fmt"
	"time"

	"github.com/google/uuid"
	"github.com/langchain-ai/langsmith-go"
)

ctx := context.Background()
client := langsmith.NewClient()

runID := "<run-id>"
startTime := time.Date(2026, 6, 1, 12, 0, 0, 0, time.UTC)
projectID := "<project-id>"
_, err := client.Runs.GetV2(ctx, runID, langsmith.RunGetV2Params{
	ProjectID: langsmith.F(projectID),
	StartTime: langsmith.F(startTime),
})
if err != nil {
	var apiErr *langsmith.Error
	if errors.As(err, &apiErr) && apiErr.StatusCode == 404 {
		fmt.Printf("Run %s not found\n", runID)
	} else {
		panic(err)
	}
}

import { Client } from "langsmith";

const client = new Client();
const project = await client.readProject({ projectName: "default" });
// A root run is its own trace, so `traceId` is also the run ID.
let traceId = "<trace-id>";

const traceRuns = await client.traces.listRuns(traceId, {
  project_id: project.id,
  selects: ["ID", "NAME", "RUN_TYPE", "PARENT_RUN_IDS", "START_TIME", "END_TIME"],
});

// `parent_run_ids` is the full ancestor chain, root first, closest parent last.
// A run is a descendant of any ID in that chain, at any depth, not only of the
// immediate parent. This flat list replaces `child_run_ids`.
const descendants = (traceRuns.items ?? []).filter((traceRun) =>
  (traceRun.parent_run_ids ?? []).includes(traceId),
);
console.log(descendants.length, "descendants");

// Optional: group the runs by immediate parent to walk the trace as a tree,
// which is the information `child_runs` used to carry.
type TraceRun = NonNullable<typeof traceRuns.items>[number];
const byParent = new Map<string, TraceRun[]>();
for (const traceRun of traceRuns.items ?? []) {
  const ancestors = traceRun.parent_run_ids ?? [];
  if (ancestors.length === 0) continue;
  // The last ancestor is the immediate parent.
  const parentId = ancestors[ancestors.length - 1];
  byParent.set(parentId, [...(byParent.get(parentId) ?? []), traceRun]);
}

const children = byParent.get(traceId) ?? [];
for (const child of children) {
  console.log(child.name, child.run_type, (byParent.get(child.id!) ?? []).length);
}

import { Client } from "langsmith";

const client = new Client();
let runId = "<run-id>";
const run = await client.readRun(runId);
const response = await client.runs.getURL(run.id, {
  project_id: run.session_id!,
  trace_id: run.trace_id!,
  start_time: String(run.start_time!), // Optional, but speeds up retrieval
});
console.log(response.url);