inspect-ai 0.3.108__py3-none-any.whl → 0.3.109__py3-none-any.whl

inspect_ai/_view/www/src/app/routing/RouteDispatcher.tsx

@@ -0,0 +1,28 @@
+import { FC } from "react";
+import { LogsPanel } from "../log-list/LogsPanel";
+import { LogViewContainer } from "../log-view/LogViewContainer";
+import { useLogRouteParams } from "./url";
+
+/**
+ * RouteDispatcher component that determines whether to show LogsView or LogViewContainer
+ * based on the logPath parameter. If logPath ends with .eval or .json, it shows the
+ * individual log view. Otherwise, it shows the logs directory view.
+ */
+export const RouteDispatcher: FC = () => {
+  const { logPath } = useLogRouteParams();
+
+  // If no logPath is provided, show the logs directory view
+  if (!logPath) {
+    return <LogsPanel />;
+  }
+
+  // Check if the path ends with .eval or .json (indicating it's a log file)
+  const isLogFile = logPath.endsWith(".eval") || logPath.endsWith(".json");
+
+  // Route to the appropriate component
+  if (isLogFile) {
+    return <LogViewContainer />;
+  } else {
+    return <LogsPanel />;
+  }
+};

inspect_ai/_view/www/src/app/routing/sampleNavigation.ts

@@ -1,9 +1,82 @@
 import { useCallback } from "react";
-import { useNavigate, useParams, useSearchParams } from "react-router-dom";
+import { useNavigate, useSearchParams } from "react-router-dom";
 import { useFilteredSamples } from "../../state/hooks";
 import { useStore } from "../../state/store";
 import { directoryRelativeUrl } from "../../utils/uri";
-import { logUrlRaw, sampleUrl } from "./url";
+import { logUrl, logUrlRaw, sampleUrl, useLogRouteParams } from "./url";
+
+export const useLogNavigation = () => {
+  const navigate = useNavigate();
+  const { logPath } = useLogRouteParams();
+  const logs = useStore((state) => state.logs.logs);
+  const loadedLog = useStore((state) => state.log.loadedLog);
+
+  const selectTab = useCallback(
+    (tabId: string) => {
+      // Only update URL if we have a loaded log
+      if (loadedLog && logPath) {
+        // We already have the logPath from params, just navigate to the tab
+        const url = logUrlRaw(logPath, tabId);
+        navigate(url);
+      } else if (loadedLog) {
+        // Fallback to constructing the path if needed
+        const url = logUrl(loadedLog, logs.log_dir, tabId);
+        navigate(url);
+      }
+    },
+    [loadedLog, logPath, logs.log_dir, navigate],
+  );
+
+  return {
+    selectTab,
+  };
+};
+
+export const useSampleUrl = () => {
+  const { logPath, tabId, sampleTabId } = useLogRouteParams();
+
+  const logDirectory = useStore((state) => state.logs.logs.log_dir);
+
+  const selectedLogFile = useStore((state) => state.logs.selectedLogFile);
+
+  // Helper function to resolve the log path for URLs
+  const resolveLogPath = useCallback(() => {
+    // If we have a logPath from URL params, use that
+    if (logPath) {
+      return logPath;
+    }
+
+    if (selectedLogFile) {
+      return directoryRelativeUrl(selectedLogFile, logDirectory);
+    }
+
+    return undefined;
+  }, [logPath, selectedLogFile, logDirectory]);
+
+  // Get a sample URL for a specific sample
+  const getSampleUrl = useCallback(
+    (
+      sampleId: string | number,
+      epoch: number,
+      specificSampleTabId?: string,
+    ) => {
+      const resolvedPath = resolveLogPath();
+      if (resolvedPath) {
+        const currentSampleTabId = specificSampleTabId || sampleTabId;
+        const url = sampleUrl(
+          resolvedPath,
+          sampleId,
+          epoch,
+          currentSampleTabId,
+        );
+        return url;
+      }
+      return undefined;
+    },
+    [resolveLogPath, tabId, sampleTabId],
+  );
+  return getSampleUrl;
+};
 
 /**
  * Hook that provides sample navigation utilities with proper URL handling
@@ -16,11 +89,7 @@ export const useSampleNavigation = () => {
   const logDirectory = useStore((state) => state.logs.logs.log_dir);
 
   // The log
-  const { logPath, tabId, sampleTabId } = useParams<{
-    logPath?: string;
-    tabId?: string;
-    sampleTabId?: string;
-  }>();
+  const { logPath, tabId, sampleTabId } = useLogRouteParams();
 
   // Get the store access values directly in the hook
   const selectedLogFile = useStore((state) => state.logs.selectedLogFile);

inspect_ai/_view/www/src/app/routing/url.ts

@@ -1,12 +1,185 @@
 import { useMemo } from "react";
 import { useParams } from "react-router-dom";
-import { kSampleMessagesTabId, kSampleTranscriptTabId } from "../../constants";
+import {
+  kSampleMessagesTabId,
+  kSampleTabIds,
+  kSampleTranscriptTabId,
+  kWorkspaceTabs,
+} from "../../constants";
 import { useStore } from "../../state/store";
-import { directoryRelativeUrl } from "../../utils/uri";
+import { directoryRelativeUrl, encodePathParts } from "../../utils/uri";
 
-export const kLogRouteUrlPattern = "/logs/:logPath/:tabId?/:sampleTabId?";
+/**
+ * Decodes a URL parameter that may be URL-encoded.
+ * Safely handles already decoded strings.
+ */
+export const decodeUrlParam = (
+  param: string | undefined,
+): string | undefined => {
+  if (!param) return param;
+  try {
+    return decodeURIComponent(param);
+  } catch {
+    // If decoding fails, return the original string
+    return param;
+  }
+};
+
+/**
+ * Hook that provides URL parameters with automatic decoding.
+ * Use this instead of useParams when you need the actual unencoded values.
+ */
+export const useDecodedParams = <
+  T extends Record<string, string | undefined>,
+>() => {
+  const params = useParams<T>();
+
+  const decodedParams = useMemo(() => {
+    const decoded = {} as T;
+    Object.entries(params).forEach(([key, value]) => {
+      (decoded as any)[key] = decodeUrlParam(value as string);
+    });
+    return decoded;
+  }, [params]);
+
+  return decodedParams;
+};
+
+/**
+ * Hook that parses log route parameters from the splat route.
+ * Handles nested paths properly by parsing the full path after /logs/
+ */
+export const useLogRouteParams = () => {
+  const params = useParams<{
+    "*": string;
+    sampleId?: string;
+    epoch?: string;
+    sampleTabId?: string;
+  }>();
+
+  return useMemo(() => {
+    const splatPath = params["*"] || "";
+
+    // Check for full sample route pattern in splat path (when route params aren't populated)
+    // Pattern: logPath/samples/sample/sampleId/epoch/sampleTabId (with optional trailing slash)
+    const fullSampleUrlMatch = splatPath.match(
+      /^(.+?)\/samples\/sample\/([^/]+)(?:\/([^/]+)(?:\/(.+?))?)?\/?\s*$/,
+    );
+    if (fullSampleUrlMatch) {
+      const [, logPath, sampleId, epoch, sampleTabId] = fullSampleUrlMatch;
+      return {
+        logPath: decodeUrlParam(logPath),
+        tabId: undefined,
+        sampleTabId: decodeUrlParam(sampleTabId),
+        sampleId: decodeUrlParam(sampleId),
+        epoch: epoch ? decodeUrlParam(epoch) : undefined,
+      };
+    }
+
+    // Check for sample URLs that might not match the formal route pattern
+    // (this is the single sample case, where is there is now sampleid/epoch, just sampletabid)
+    // Pattern: /logs/*/samples/sampleId/epoch or /logs/*/samples/sampleId or /logs/*/samples/sampleTabId
+    const sampleUrlMatch = splatPath.match(
+      /^(.+?)\/samples(?:\/([^/]+)(?:\/([^/]+))?)?$/,
+    );
+    if (sampleUrlMatch) {
+      const [, logPath, firstSegment, secondSegment] = sampleUrlMatch;
+
+      if (firstSegment) {
+        // Define known sample tab IDs
+        const validSampleTabIds = new Set(kSampleTabIds);
+
+        if (validSampleTabIds.has(firstSegment) && !secondSegment) {
+          // This is /logs/*/samples/sampleTabId
+          return {
+            logPath: decodeUrlParam(logPath),
+            tabId: "samples",
+            sampleTabId: decodeUrlParam(firstSegment),
+            sampleId: undefined,
+            epoch: undefined,
+          };
+        } else {
+          // This is a sample URL with sampleId (and possibly epoch)
+          return {
+            logPath: decodeUrlParam(logPath),
+            tabId: undefined,
+            sampleTabId: undefined,
+            sampleId: decodeUrlParam(firstSegment),
+            epoch: secondSegment ? decodeUrlParam(secondSegment) : undefined,
+          };
+        }
+      } else {
+        // This is just /logs/*/samples (samples listing)
+        return {
+          logPath: decodeUrlParam(logPath),
+          tabId: "samples",
+          sampleTabId: undefined,
+          sampleId: undefined,
+          epoch: undefined,
+        };
+      }
+    }
+
+    // Regular log route pattern: /logs/path/to/file.eval/tabId?
+    // Split the path and check if the last segment might be a tabId
+    const pathSegments = splatPath.split("/").filter(Boolean);
+
+    if (pathSegments.length === 0) {
+      return {
+        logPath: undefined,
+        tabId: undefined,
+        sampleTabId: undefined,
+        sampleId: undefined,
+        epoch: undefined,
+      };
+    }
+
+    // Define valid tab IDs for log view
+    const validTabIds = new Set(kWorkspaceTabs);
+
+    // Look for the first valid tab ID from right to left
+    let tabIdIndex = -1;
+    let foundTabId: string | undefined = undefined;
+
+    for (let i = pathSegments.length - 1; i >= 0; i--) {
+      const segment = pathSegments[i];
+      const decodedSegment = decodeUrlParam(segment) || segment;
+
+      if (validTabIds.has(decodedSegment)) {
+        tabIdIndex = i;
+        foundTabId = decodedSegment;
+        break;
+      }
+    }
+
+    if (foundTabId && tabIdIndex > 0) {
+      // Found a valid tab ID, split the path there
+      const logPath = pathSegments.slice(0, tabIdIndex).join("/");
+
+      return {
+        logPath: decodeUrlParam(logPath),
+        tabId: foundTabId,
+        sampleTabId: undefined,
+        sampleId: undefined,
+        epoch: undefined,
+      };
+    } else {
+      // No valid tab ID found, the entire path is the logPath
+      return {
+        logPath: decodeUrlParam(splatPath),
+        tabId: undefined,
+        sampleTabId: undefined,
+        sampleId: undefined,
+        epoch: undefined,
+      };
+    }
+  }, [params]);
+};
+
+export const kLogsRoutUrlPattern = "/logs";
+export const kLogRouteUrlPattern = "/logs/*";
 export const kSampleRouteUrlPattern =
-  "/logs/:logPath/samples/sample/:sampleId/:epoch?/:sampleTabId?";
+  "/logs/*/samples/sample/:sampleId/:epoch?/:sampleTabId?";
 
 export const baseUrl = (
   logPath: string,
@@ -26,10 +199,17 @@ export const sampleUrl = (
   sampleEpoch?: string | number,
   sampleTabId?: string,
 ) => {
+  // Ensure logPath is decoded before encoding for URL construction
+  const decodedLogPath = decodeUrlParam(logPath) || logPath;
+
   if (sampleId !== undefined && sampleEpoch !== undefined) {
-    return `/logs/${encodeURIComponent(logPath)}/samples/sample/${encodeURIComponent(sampleId)}/${sampleEpoch}/${sampleTabId || ""}`;
+    return encodePathParts(
+      `/logs/${decodedLogPath}/samples/sample/${sampleId}/${sampleEpoch}/${sampleTabId || ""}`,
+    );
   } else {
-    return `/logs/${encodeURIComponent(logPath)}/samples/${sampleTabId || ""}`;
+    return encodePathParts(
+      `/logs/${decodedLogPath}/samples/${sampleTabId || ""}`,
+    );
   }
 };
 
@@ -58,12 +238,7 @@ export const useSampleMessageUrl = (
     logPath: urlLogPath,
     sampleId: urlSampleId,
     epoch: urlEpoch,
-  } = useParams<{
-    logPath?: string;
-    tabId?: string;
-    sampleId?: string;
-    epoch?: string;
-  }>();
+  } = useLogRouteParams();
 
   const log_file = useStore((state) => state.logs.selectedLogFile);
   const log_dir = useStore((state) => state.logs.logs.log_dir);
@@ -95,12 +270,7 @@ export const useSampleEventUrl = (
     logPath: urlLogPath,
     sampleId: urlSampleId,
     epoch: urlEpoch,
-  } = useParams<{
-    logPath?: string;
-    tabId?: string;
-    sampleId?: string;
-    epoch?: string;
-  }>();
+  } = useLogRouteParams();
 
   const log_file = useStore((state) => state.logs.selectedLogFile);
   const log_dir = useStore((state) => state.logs.logs.log_dir);
@@ -149,10 +319,13 @@ export const makeLogPath = (log_file: string, log_dir?: string) => {
 };
 
 export const logUrlRaw = (log_segment: string, tabId?: string) => {
+  // Ensure log_segment is decoded before encoding for URL construction
+  const decodedLogSegment = decodeUrlParam(log_segment) || log_segment;
+
   if (tabId) {
-    return `/logs/${encodeURIComponent(log_segment)}/${tabId}`;
+    return encodePathParts(`/logs/${decodedLogSegment}/${tabId}`);
   } else {
-    return `/logs/${encodeURIComponent(log_segment)}`;
+    return encodePathParts(`/logs/${decodedLogSegment}`);
   }
 };
 

inspect_ai/_view/www/src/app/samples/SampleDisplay.tsx

@@ -38,7 +38,7 @@ import { estimateSize } from "../../utils/json";
 import { printHeadingHtml, printHtml } from "../../utils/print";
 import { RecordTree } from "../content/RecordTree";
 import { useSampleDetailNavigation } from "../routing/sampleNavigation";
-import { sampleUrl } from "../routing/url";
+import { sampleUrl, useLogRouteParams } from "../routing/url";
 import { ModelTokenTable } from "../usage/ModelTokenTable";
 import { ChatViewVirtualList } from "./chat/ChatViewVirtualList";
 import { messagesFromEvents } from "./chat/messages";
@@ -113,15 +113,9 @@ export const SampleDisplay: FC<SampleDisplayProps> = ({ id, scrollRef }) => {
   // Get all URL parameters at component level
   const {
     logPath: urlLogPath,
-    tabId: urlTabId,
     sampleId: urlSampleId,
     epoch: urlEpoch,
-  } = useParams<{
-    logPath?: string;
-    tabId?: string;
-    sampleId?: string;
-    epoch?: string;
-  }>();
+  } = useLogRouteParams();
 
   // Tab selection
   const onSelectedTab = useCallback(
@@ -136,15 +130,7 @@ export const SampleDisplay: FC<SampleDisplayProps> = ({ id, scrollRef }) => {
         navigate(url);
       }
     },
-    [
-      sampleTabId,
-      urlLogPath,
-      urlTabId,
-      urlSampleId,
-      urlEpoch,
-      navigate,
-      setSelectedTab,
-    ],
+    [sampleTabId, urlLogPath, urlSampleId, urlEpoch, navigate, setSelectedTab],
   );
 
   const sampleMetadatas = metadataViewsForSample(

inspect_ai/_view/www/src/app/samples/descriptor/score/ScoreDescriptor.tsx

@@ -46,7 +46,7 @@ const scoreCategorizers: ScoreCategorizer[] = [
           return val === 1 || val === 0;
         })
       ) {
-        return booleanScoreDescriptor();
+        return numericScoreDescriptor(values);
       }
     },
   },

inspect_ai/_view/www/src/app/samples/transcript/SubtaskEventView.tsx

@@ -2,7 +2,7 @@ import clsx from "clsx";
 import { FC, ReactNode } from "react";
 import { Input2, Input5, Result2, SubtaskEvent } from "../../../@types/log";
 import { ApplicationIcons } from "../../appearance/icons";
-import { MetaDataView } from "../../content/MetaDataView";
+import { MetaDataGrid } from "../../content/MetaDataGrid";
 import { EventPanel } from "./event/EventPanel";
 import { formatTiming, formatTitle } from "./event/utils";
 import styles from "./SubtaskEventView.module.css";
@@ -106,7 +106,7 @@ const Rendered: FC<RenderedProps> = ({ values }) => {
     if (Object.keys(values).length === 0) {
       return <None />;
     } else {
-      return <MetaDataView entries={values as Record<string, unknown>} />;
+      return <MetaDataGrid entries={values as Record<string, unknown>} />;
     }
   } else {
     return values;

inspect_ai/_view/www/src/app/samples/transcript/TranscriptPanel.tsx

@@ -1,10 +1,10 @@
 import clsx from "clsx";
 import { FC, memo, RefObject } from "react";
-import { useParams } from "react-router-dom";
 import { Events } from "../../../@types/log";
 import { StickyScroll } from "../../../components/StickyScroll";
 import { useCollapsedState } from "../../../state/hooks";
 import { ApplicationIcons } from "../../appearance/icons";
+import { useLogRouteParams } from "../../routing/url";
 import { TranscriptOutline } from "./outline/TranscriptOutline";
 import styles from "./TranscriptPanel.module.css";
 import { TranscriptVirtualList } from "./TranscriptVirtualList";
@@ -29,7 +29,7 @@ export const TranscriptPanel: FC<TranscriptPanelProps> = memo((props) => {
     events,
     running === true,
   );
-  const { logPath } = useParams<{ logPath: string }>();
+  const { logPath } = useLogRouteParams();
 
   const [collapsed, setCollapsed] = useCollapsedState(
     `transcript-panel-${logPath || "na"}`,

inspect_ai/_view/www/src/app/samples/transcript/outline/tree-visitors.ts

@@ -141,6 +141,11 @@ export const collapseTurns = (eventNodes: EventNode[]): EventNode[] => {
 
   for (const node of eventNodes) {
     if (node.event.event === "span_begin" && node.event.type === kTurnType) {
+      // Check depth to ensure we are collecting turns at the same level
+      if (collecting.length > 0 && collecting[0].depth !== node.depth) {
+        collect();
+      }
+
       collecting.push(node);
     } else {
       collect();

inspect_ai/_view/www/src/app/samples/transcript/transform/treeify.ts

@@ -349,15 +349,31 @@ const transformers = () => {
     },
     {
       name: "unwrap_handoff",
-      matches: (node) =>
-        node.event.event === SPAN_BEGIN &&
-        node.event["type"] === TYPE_HANDOFF &&
-        node.children.length === 2 &&
-        node.children[0].event.event === TOOL &&
-        node.children[1].event.event === STORE &&
-        node.children[0].children.length === 2 &&
-        node.children[0].children[0].event.event === SPAN_BEGIN &&
-        node.children[0].children[0].event.type === TYPE_AGENT,
+      matches: (node) => {
+        const isHandoffNode =
+          node.event.event === SPAN_BEGIN &&
+          node.event["type"] === TYPE_HANDOFF;
+
+        if (!isHandoffNode) {
+          return false;
+        }
+
+        if (node.children.length === 1) {
+          return (
+            node.children[0].event.event === TOOL &&
+            !!node.children[0].event.agent
+          );
+        } else {
+          return (
+            node.children.length === 2 &&
+            node.children[0].event.event === TOOL &&
+            node.children[1].event.event === STORE &&
+            node.children[0].children.length === 2 &&
+            node.children[0].children[0].event.event === SPAN_BEGIN &&
+            node.children[0].children[0].event.type === TYPE_AGENT
+          );
+        }
+      },
       process: (node) => skipThisNode(node),
     },
     {
@@ -423,7 +439,7 @@ const skipFirstChildNode = (node: EventNode): EventNode => {
 const skipThisNode = (node: EventNode): EventNode => {
   const newNode = { ...node.children[0] };
   newNode.depth = node.depth;
-  newNode.children = reduceDepth(newNode.children[0].children, 2);
+  newNode.children = reduceDepth(newNode.children, 2);
   return newNode;
 };
 

inspect_ai/_view/www/src/app/types.ts

@@ -1,3 +1,8 @@
+import {
+  ColumnFiltersState,
+  ColumnResizeMode,
+  SortingState,
+} from "@tanstack/react-table";
 import { StateSnapshot } from "react-virtuoso";
 import {
   ApprovalEvent,
@@ -22,6 +27,7 @@ import {
   EvalLogHeader,
   EvalSummary,
   EventData,
+  LogFile,
   LogFiles,
   PendingSamples,
   SampleSummary,
@@ -30,7 +36,6 @@ import { ScorerInfo } from "../state/scoring";
 
 export interface AppState {
   status: AppStatus;
-  offcanvas: boolean;
   showFind: boolean;
   tabs: {
     workspace: string;
@@ -51,6 +56,8 @@ export interface AppState {
     sample_epoch?: string;
   };
   rehydrated?: boolean;
+  pagination: Record<string, { page: number; pageSize: number }>;
+  singleFileMode?: boolean;
 }
 
 export interface LogsState {
@@ -59,6 +66,19 @@ export interface LogsState {
   headersLoading: boolean;
   selectedLogIndex: number;
   selectedLogFile?: string;
+  listing: LogsListing;
+  loadingFiles: Set<string>;
+  pendingRequests: Map<string, Promise<EvalLogHeader | null>>;
+}
+
+export interface LogsListing {
+  sorting?: SortingState;
+  filtering?: ColumnFiltersState;
+  globalFilter?: string;
+  columnResizeMode?: ColumnResizeMode;
+  columnSizes?: Record<string, number>;
+  filteredCount?: number;
+  watchedLogs?: LogFile[];
 }
 
 export interface LogState {

inspect_ai/_view/www/src/client/api/api-http.ts

@@ -1,7 +1,8 @@
 import { EvalLog } from "../../@types/log";
 import { asyncJsonParse } from "../../utils/json-worker";
+import { encodePathParts } from "../../utils/uri";
 import { fetchRange, fetchSize } from "../remote/remoteZipFile";
-import { download_file, encodePathParts } from "./api-shared";
+import { download_file } from "./api-shared";
 import {
   Capabilities,
   LogContents,

inspect_ai/_view/www/src/client/api/api-shared.ts

@@ -13,35 +13,3 @@ export async function download_file(
   link.click();
   document.body.removeChild(link);
 }
-
-/**
- * Encodes the path segments of a URL or relative path to ensure special characters
- * (like `+`, spaces, etc.) are properly encoded without affecting legal characters like `/`.
- *
- * This function will encode file names and path portions of both absolute URLs and
- * relative paths. It ensures that components of a full URL, such as the protocol and
- * query parameters, remain intact, while only encoding the path.
- */
-export function encodePathParts(url: string): string {
-  if (!url) return url; // Handle empty strings
-
-  try {
-    // Parse a full Uri
-    const fullUrl = new URL(url);
-    fullUrl.pathname = fullUrl.pathname
-      .split("/")
-      .map((segment) =>
-        segment ? encodeURIComponent(decodeURIComponent(segment)) : "",
-      )
-      .join("/");
-    return fullUrl.toString();
-  } catch {
-    // This is a relative path that isn't parseable as Uri
-    return url
-      .split("/")
-      .map((segment) =>
-        segment ? encodeURIComponent(decodeURIComponent(segment)) : "",
-      )
-      .join("/");
-  }
-}

inspect_ai/_view/www/src/client/api/client-api.ts

@@ -1,11 +1,11 @@
 import { EvalLog, EvalSample } from "../../@types/log";
+import { encodePathParts } from "../../utils/uri";
 import {
   openRemoteLogFile,
   RemoteLogFile,
   SampleNotFoundError,
 } from "../remote/remoteLogFile";
 import { FileSizeLimitError } from "../remote/remoteZipFile";
-import { encodePathParts } from "./api-shared";
 import {
   ClientAPI,
   EvalSummary,