feat: revamp of session view

.gitignore

@@ -6,4 +6,4 @@
 target/
 .claude/
 .agent-browser/
-.agent-team/TODO.md
+.agent-team/

app-server/src/main.rs

@@ -1616,7 +1616,8 @@ fn main() -> anyhow::Result<()> {
                                     .service(routes::spans::search_spans)
                                     .service(routes::rollouts::run)
                                     .service(routes::rollouts::update_status)
-                                    .service(routes::signals::submit_signal_job),
+                                    .service(routes::signals::submit_signal_job)
+                                    .service(routes::spans::get_skeleton_hashes),
                             )
                             .service(routes::probes::check_health)
                             .service(routes::probes::check_ready)

app-server/src/routes/spans.rs

@@ -13,6 +13,7 @@ use crate::{
     quickwit::client::QuickwitClient,
     routes::ResponseResult,
     search::snippets::SearchSpanHit,
+    signals::utils::structural_skeleton_hash,
     traces::{OBSERVATIONS_EXCHANGE, OBSERVATIONS_ROUTING_KEY, spans::SpanAttributes},
 };
 
@@ -149,3 +150,26 @@ pub async fn search_spans(
 
     Ok(HttpResponse::Ok().json(results))
 }
+
+#[derive(Deserialize)]
+pub struct SkeletonHashRequest {
+    pub texts: Vec<String>,
+}
+
+#[post("skeleton-hashes")]
+pub async fn get_skeleton_hashes(
+    _project_id: web::Path<Uuid>,
+    request: web::Json<SkeletonHashRequest>,
+) -> ResponseResult {
+    let texts = &request.texts;
+
+    if texts.is_empty() || texts.len() > 200 {
+        return Ok(HttpResponse::BadRequest().json(serde_json::json!({
+            "error": "texts must contain between 1 and 200 items"
+        })));
+    }
+
+    let hashes: Vec<String> = texts.iter().map(|t| structural_skeleton_hash(t)).collect();
+
+    Ok(HttpResponse::Ok().json(hashes))
+}

frontend/app/api/projects/[projectId]/traces/io/route.ts

@@ -0,0 +1,18 @@
+import { type NextRequest } from "next/server";
+import { prettifyError, ZodError } from "zod/v4";
+
+import { getMainAgentIOBatch } from "@/lib/actions/sessions/trace-io";
+
+export async function POST(req: NextRequest, props: { params: Promise<{ projectId: string }> }): Promise<Response> {
+  const { projectId } = await props.params;
+  try {
+    const body = await req.json();
+    const result = await getMainAgentIOBatch({ ...body, projectId });
+    return Response.json(result);
+  } catch (error) {
+    if (error instanceof ZodError) {
+      return Response.json({ error: prettifyError(error) }, { status: 400 });
+    }
+    return Response.json({ error: error instanceof Error ? error.message : "Internal server error" }, { status: 500 });
+  }
+}

frontend/components/common/advanced-search/index.tsx

@@ -21,7 +21,7 @@ import {
 
 interface AdvancedSearchInnerProps {
   filters: ColumnFilter[];
-  resource: "traces" | "spans";
+  resource?: "traces" | "spans";
   placeholder?: string;
   className?: string;
   disabled?: boolean;
@@ -105,7 +105,7 @@ const AdvancedSearchInner = ({
   }, [urlTags, setTags, updateLastSubmitted, mode]);
 
   useSWR<{ suggestions: AutocompleteSuggestion[] }>(
-    suggestions ? null : `/api/projects/${projectId}/${resource}/autocomplete`,
+    suggestions || !resource ? null : `/api/projects/${projectId}/${resource}/autocomplete`,
     swrFetcher,
     {
       onSuccess: (data) => {
@@ -146,7 +146,7 @@ AdvancedSearchInner.displayName = "AdvancedSearchInner";
 
 interface AdvancedSearchProps {
   filters: ColumnFilter[];
-  resource: "traces" | "spans";
+  resource?: "traces" | "spans";
   placeholder?: string;
   className?: string;
   disabled?: boolean;

frontend/components/common/advanced-search/store/index.tsx

@@ -247,7 +247,9 @@ function createCoreSlice(
 
     submit: (router, pathname, searchParams) => {
       const { tags, inputValue, onSubmit, mode } = get();
-      const filterObjects = tags.map(createFilterFromTag);
+      // Skip incomplete tags (empty value) so we don't submit invalid filters
+      const completeTags = tags.filter((t) => (Array.isArray(t.value) ? t.value.length > 0 : t.value !== ""));
+      const filterObjects = completeTags.map(createFilterFromTag);
       const searchValue = inputValue.trim();
 
       set({ isOpen: false, activeIndex: -1, activeRecentIndex: -1 });

frontend/components/traces/sessions-table/columns.tsx

@@ -1,32 +1,11 @@
-import { ChevronDownIcon } from "@radix-ui/react-icons";
-import { type ColumnDef } from "@tanstack/react-table";
-import { ChevronRightIcon } from "lucide-react";
-
-import ClientTimestampFormatter from "@/components/client-timestamp-formatter";
-import TagsCell from "@/components/tags/tags-cell";
 import { type ColumnFilter } from "@/components/ui/infinite-datatable/ui/datatable-filter/utils";
-import Mono from "@/components/ui/mono";
-import { type SessionRow } from "@/lib/traces/types";
-import { getDurationString } from "@/lib/utils";
-
-const format = new Intl.NumberFormat("en-US", {
-  style: "currency",
-  currency: "USD",
-  maximumFractionDigits: 5,
-  minimumFractionDigits: 1,
-});
 
 export const filters: ColumnFilter[] = [
   {
     key: "session_id",
     name: "Session ID",
     dataType: "string",
   },
-  {
-    key: "user_id",
-    name: "User ID",
-    dataType: "string",
-  },
   {
     key: "trace_count",
     name: "Trace Count",
@@ -42,157 +21,9 @@ export const filters: ColumnFilter[] = [
     name: "Total Tokens",
     dataType: "number",
   },
-  {
-    key: "input_tokens",
-    name: "Input Tokens",
-    dataType: "number",
-  },
-  {
-    key: "output_tokens",
-    name: "Output Tokens",
-    dataType: "number",
-  },
   {
     key: "total_cost",
     name: "Total Cost",
     dataType: "number",
   },
-  {
-    key: "input_cost",
-    name: "Input Cost",
-    dataType: "number",
-  },
-  {
-    key: "output_cost",
-    name: "Output Cost",
-    dataType: "number",
-  },
-  {
-    key: "tags",
-    name: "Span tags",
-    dataType: "string",
-  },
-];
-
-export const columns: ColumnDef<SessionRow, any>[] = [
-  {
-    header: "Type",
-    cell: ({ row }) =>
-      row.original?.subRows ? (
-        <div className="flex items-center gap-2">
-          <span className="">Session</span>
-          {row.getIsExpanded() ? (
-            <ChevronDownIcon className="w-4 text-secondary-foreground" />
-          ) : (
-            <ChevronRightIcon className="w-4 text-secondary-foreground" />
-          )}
-        </div>
-      ) : (
-        <div>
-          <span className="text-gray-500">Trace</span>
-        </div>
-      ),
-    id: "type",
-    size: 120,
-  },
-  {
-    accessorFn: (row) => row.id || row.sessionId,
-    header: "ID",
-    id: "id",
-    cell: (row) => <Mono className="text-xs">{row.getValue()}</Mono>,
-  },
-  {
-    accessorFn: (row) => row.startTime,
-    header: "Start time",
-    cell: (row) => <ClientTimestampFormatter timestamp={String(row.getValue())} />,
-    id: "start_time",
-    size: 150,
-  },
-  {
-    accessorFn: (row) => {
-      if (!row?.subRows) {
-        return getDurationString(row.startTime, row.endTime);
-      }
-
-      return row.duration.toFixed(2) + "s";
-    },
-    header: "Duration",
-    id: "duration",
-    size: 100,
-  },
-  {
-    accessorFn: (row) => format.format(row.inputCost),
-    header: "Input cost",
-    id: "input_cost",
-    size: 120,
-  },
-  {
-    accessorFn: (row) => format.format(row.outputCost),
-    header: "Output cost",
-    id: "output_cost",
-    size: 120,
-  },
-  {
-    accessorFn: (row) => format.format(row.totalCost),
-    header: "Total cost",
-    id: "total_cost",
-    size: 120,
-  },
-  {
-    accessorFn: (row) => row.inputTokens,
-    header: "Input tokens",
-    id: "input_tokens",
-    size: 120,
-  },
-  {
-    accessorFn: (row) => row.outputTokens,
-    header: "Output tokens",
-    id: "output_tokens",
-    size: 120,
-  },
-  {
-    accessorFn: (row) => row.totalTokens,
-    header: "Total tokens",
-    id: "total_tokens",
-    size: 120,
-  },
-  {
-    accessorFn: (row) => (row?.subRows ? row.traceCount || 0 : "-"),
-    header: "Trace Count",
-    id: "trace_count",
-    size: 120,
-  },
-  {
-    accessorFn: (row) => (row?.subRows ? "-" : row.userId),
-    header: "User ID",
-    id: "user_id",
-    cell: (row) => <Mono className="text-xs">{row.getValue() || "-"}</Mono>,
-  },
-  {
-    accessorFn: (row) => ("spanTags" in row ? row.spanTags : "-"),
-    cell: (row) => {
-      const tags = row.getValue() as string[];
-      if (Array.isArray(tags) && tags?.length > 0) return <TagsCell tags={tags} />;
-      return "-";
-    },
-    header: "Span tags",
-    accessorKey: "spanTags",
-    id: "span_tags",
-  },
-];
-
-export const defaultSessionsColumnOrder = [
-  "type",
-  "id",
-  "start_time",
-  "duration",
-  "input_cost",
-  "output_cost",
-  "total_cost",
-  "input_tokens",
-  "output_tokens",
-  "total_tokens",
-  "trace_count",
-  "user_id",
-  "span_tags",
 ];