inspect-ai 0.3.58__py3-none-any.whl → 0.3.60__py3-none-any.whl

inspect_ai/_view/www/src/api/{api-vscode.mjs → api-vscode.ts}

@@ -1,7 +1,4 @@
-//@ts-check
-
-import { asyncJsonParse } from "../utils/Json.mjs";
-// @ts-ignore
+import { asyncJsonParse } from "../utils/json-worker";
 import JSON5 from "json5";
 
 import {
@@ -11,8 +8,9 @@ import {
   kMethodEvalLogSize,
   kMethodEvalLogBytes,
   kMethodEvalLogHeaders,
-} from "./jsonrpc.mjs";
-import { getVscodeApi } from "../utils/vscode.mjs";
+} from "./jsonrpc";
+import { getVscodeApi } from "../utils/vscode";
+import { Capabilities, LogContents, LogViewAPI } from "./Types";
 
 const vscodeClient = webViewJsonRpcClient(getVscodeApi());
 
@@ -38,8 +36,12 @@ async function eval_logs() {
   }
 }
 
-async function eval_log(file, headerOnly, capabilities) {
-  const response = await vscodeClient(kMethodEvalLog, [file, headerOnly]);
+async function eval_log(
+  log_file: string,
+  headerOnly?: number,
+  capabilities?: Capabilities,
+): Promise<LogContents> {
+  const response = await vscodeClient(kMethodEvalLog, [log_file, headerOnly]);
   if (response) {
     let json;
     if (capabilities?.webWorkers) {
@@ -52,19 +54,19 @@ async function eval_log(file, headerOnly, capabilities) {
       raw: response,
     };
   } else {
-    return undefined;
+    throw new Error(`Unable to load eval log ${log_file}.`);
   }
 }
 
-async function eval_log_size(file) {
-  return await vscodeClient(kMethodEvalLogSize, [file]);
+async function eval_log_size(log_file: string) {
+  return await vscodeClient(kMethodEvalLogSize, [log_file]);
 }
 
-async function eval_log_bytes(file, start, end) {
-  return await vscodeClient(kMethodEvalLogBytes, [file, start, end]);
+async function eval_log_bytes(log_file: string, start: number, end: number) {
+  return await vscodeClient(kMethodEvalLogBytes, [log_file, start, end]);
 }
 
-async function eval_log_headers(files) {
+async function eval_log_headers(files: string[]) {
   const response = await vscodeClient(kMethodEvalLogHeaders, [files]);
   if (response) {
     return JSON5.parse(response);
@@ -77,17 +79,16 @@ async function download_file() {
   throw Error("Downloading files is not supported in VS Code");
 }
 
-async function open_log_file(url, log_dir) {
+async function open_log_file(log_file: string, log_dir: string) {
   const msg = {
     type: "displayLogFile",
-    url: url,
+    url: log_file,
     log_dir: log_dir,
   };
-  getVscodeApi().postMessage(msg);
+  getVscodeApi()?.postMessage(msg);
 }
 
-/** @type {import("./Types.mjs").LogViewAPI} */
-export default {
+const api: LogViewAPI = {
   client_events,
   eval_logs,
   eval_log,
@@ -97,3 +98,5 @@ export default {
   download_file,
   open_log_file,
 };
+
+export default api;

inspect_ai/_view/www/src/api/{client-api.mjs → client-api.ts}

@@ -1,71 +1,81 @@
-//@ts-check
-import { openRemoteLogFile } from "../log/remoteLogFile.mjs";
+import { openRemoteLogFile, RemoteLogFile } from "../log/remoteLogFile";
+import { EvalLog, EvalSample } from "../types/log";
 import { FileSizeLimitError } from "../utils/remoteZipFile.mjs";
+import { encodePathParts } from "./api-shared";
+import {
+  ClientAPI,
+  EvalSummary,
+  LogContents,
+  LogViewAPI,
+  LogFiles,
+} from "./Types";
 
-const isEvalFile = (file) => {
+const isEvalFile = (file: string) => {
   return file.endsWith(".eval");
 };
 
 /**
  * Represents an error thrown when a file exceeds the maximum allowed size.
- *
- * @class
- * @extends {Error}
  */
 export class SampleSizeLimitedExceededError extends Error {
-  /**
-   * Creates a new SizeLimitedExceededError.
-   *
-   * @param {string | number} id - The name of the file that caused the error.
-   * @param {number} epoch - The name of the file that caused the error.
-   * @param {number} maxBytes - The maximum allowed size for the file, in bytes.
-   */
-  constructor(id, epoch, maxBytes) {
+  readonly id: string | number;
+  readonly epoch: number;
+  readonly maxBytes: number;
+  readonly displayStack: boolean;
+
+  constructor(id: string | number, epoch: number, maxBytes: number) {
     super(
       `Sample ${id} in epoch ${epoch} exceeds the maximum supported size (${maxBytes / 1024 / 1024}MB) and cannot be loaded.`,
     );
+
     this.name = "SampleSizeLimitedExceededError";
     this.id = id;
     this.epoch = epoch;
     this.maxBytes = maxBytes;
     this.displayStack = false;
+
+    Object.setPrototypeOf(this, SampleSizeLimitedExceededError.prototype);
   }
 }
+interface LoadedLogFile {
+  file?: string;
+  remoteLog?: RemoteLogFile;
+}
 
 /**
  * This provides an API implementation that will serve a single
  * file using an http parameter, designed to be deployed
  * to a webserver without inspect or the ability to enumerate log
  * files
- *
- * @param { import("./Types.mjs").LogViewAPI } api - The api to use when loading logs
- * @returns { import("./Types.mjs").ClientAPI } A Client API for the viewer
  */
-export const clientApi = (api) => {
-  let current_log = undefined;
-  let current_path = undefined;
+export const clientApi = (api: LogViewAPI, log_file?: string): ClientAPI => {
+  let current_log: LogContents | undefined = undefined;
+  let current_path: string | undefined = undefined;
 
-  const loadedEvalFile = {
+  const loadedEvalFile: LoadedLogFile = {
     file: undefined,
     remoteLog: undefined,
   };
 
-  const remoteEvalFile = async (log_file, cached = false) => {
+  const remoteEvalFile = async (log_file: string, cached: boolean = false) => {
     if (!cached || loadedEvalFile.file !== log_file) {
       loadedEvalFile.file = log_file;
-      loadedEvalFile.remoteLog = await openRemoteLogFile(api, log_file, 5);
+      loadedEvalFile.remoteLog = await openRemoteLogFile(
+        api,
+        encodePathParts(log_file),
+        5,
+      );
     }
     return loadedEvalFile.remoteLog;
   };
 
   /**
    * Gets a log
-   *
-   * @param { string } log_file - The api to use when loading logs
-   * @param { boolean } cached - allow this request to use a cached log file
-   * @returns { Promise<import("./Types.mjs").LogContents> } A Log Viewer API
    */
-  const get_log = async (log_file, cached = false) => {
+  const get_log = async (
+    log_file: string,
+    cached = false,
+  ): Promise<LogContents> => {
     // If the requested log is different or no cached log exists, start fetching
     if (!cached || log_file !== current_path || !current_log) {
       // If there's already a pending fetch, return the same promise
@@ -91,22 +101,23 @@ export const clientApi = (api) => {
     }
     return current_log;
   };
-  let pending_log_promise = null;
+  let pending_log_promise: Promise<LogContents> | null = null;
 
   /**
    * Gets a log summary
-   *
-   * @param { string } log_file - The api to use when loading logs
-   * @returns { Promise<import("./Types.mjs").EvalSummary> } A Log Viewer API
    */
-  const get_log_summary = async (log_file) => {
+  const get_log_summary = async (log_file: string): Promise<EvalSummary> => {
     if (isEvalFile(log_file)) {
       const remoteLogFile = await remoteEvalFile(log_file);
-      return await remoteLogFile.readLogSummary();
+      if (remoteLogFile) {
+        return await remoteLogFile.readLogSummary();
+      } else {
+        throw new Error("Unable to read remote eval file");
+      }
     } else {
       const logContents = await get_log(log_file);
       /**
-       * @type {import("./Types.mjs").SampleSummary[]}
+       * @type {import("./Types.js").SampleSummary[]}
        */
       const sampleSummaries = logContents.parsed.samples
         ? logContents.parsed.samples?.map((sample) => {
@@ -138,18 +149,21 @@ export const clientApi = (api) => {
 
   /**
    * Gets a sample
-   *
-   * @param { string } log_file - The api to use when loading logs
-   * @param { string | number } id - The api to use when loading logs
-   * @param { number } epoch - The api to use when loading logs
-   * @returns { Promise<import("../types/log").EvalSample | undefined> }  The sample
    */
-  const get_log_sample = async (log_file, id, epoch) => {
+  const get_log_sample = async (
+    log_file: string,
+    id: string | number,
+    epoch: number,
+  ): Promise<EvalSample | undefined> => {
     if (isEvalFile(log_file)) {
       const remoteLogFile = await remoteEvalFile(log_file, true);
       try {
-        const sample = await remoteLogFile.readSample(id, epoch);
-        return sample;
+        if (remoteLogFile) {
+          const sample = await remoteLogFile.readSample(String(id), epoch);
+          return sample;
+        } else {
+          throw new Error(`Unable to read remove eval file ${log_file}`);
+        }
       } catch (error) {
         if (error instanceof FileSizeLimitError) {
           throw new SampleSizeLimitedExceededError(id, epoch, error.maxBytes);
@@ -168,21 +182,22 @@ export const clientApi = (api) => {
     return undefined;
   };
 
-  const get_eval_log_header = async (log_file) => {
+  const get_eval_log_header = async (log_file: string) => {
     // Don't re-use the eval log file since we know these are all different log files
-    const remoteLogFile = await openRemoteLogFile(api, log_file, 5);
+    const remoteLogFile = await openRemoteLogFile(
+      api,
+      encodePathParts(log_file),
+      5,
+    );
     return remoteLogFile.readHeader();
   };
 
   /**
    * Gets log headers
-   *
-   * @param { string[] } log_files - The api to use when loading logs
-   * @returns { Promise<import("../types/log").EvalLog[]> }  The sample
    */
-  const get_log_headers = async (log_files) => {
-    const eval_files = {};
-    const json_files = {};
+  const get_log_headers = async (log_files: string[]): Promise<EvalLog[]> => {
+    const eval_files: Record<string, number> = {};
+    const json_files: Record<string, number> = {};
     let index = 0;
 
     // Separate files into eval_files and json_files
@@ -226,12 +241,34 @@ export const clientApi = (api) => {
     return orderedHeaders.map(({ header }) => header);
   };
 
+  const get_log_paths = async (): Promise<LogFiles> => {
+    const logFiles = await api.eval_logs();
+    if (logFiles) {
+      return logFiles!;
+    } else if (log_file) {
+      // Is there an explicitly passed log file?
+      const summary = await get_log_summary(log_file);
+      if (summary) {
+        return {
+          files: [
+            {
+              name: log_file,
+              task: summary.eval.task,
+              task_id: summary.eval.task_id,
+            },
+          ],
+        };
+      }
+    }
+    throw new Error("Unable to determine log paths.");
+  };
+
   return {
     client_events: () => {
       return api.client_events();
     },
     get_log_paths: () => {
-      return api.eval_logs();
+      return get_log_paths();
     },
     get_log_headers: (log_files) => {
       return get_log_headers(log_files);
@@ -241,7 +278,10 @@ export const clientApi = (api) => {
     open_log_file: (log_file, log_dir) => {
       return api.open_log_file(log_file, log_dir);
     },
-    download_file: (download_file, file_contents) => {
+    download_file: (
+      download_file: string,
+      file_contents: string | Blob | ArrayBuffer | ArrayBufferView,
+    ) => {
       return api.download_file(download_file, file_contents);
     },
   };

inspect_ai/_view/www/src/api/index.ts

@@ -0,0 +1,51 @@
+import browserApi from "./api-browser";
+import vscodeApi from "./api-vscode";
+import simpleHttpApi from "./api-http";
+import { dirname } from "../utils/Path.mjs";
+import { getVscodeApi } from "../utils/vscode";
+import { clientApi } from "./client-api";
+import { ClientAPI } from "./Types";
+
+//
+/**
+ * Resolves the client API
+ */
+const resolveApi = (): ClientAPI => {
+  if (getVscodeApi()) {
+    // This is VSCode
+    return clientApi(vscodeApi);
+  } else {
+    // See if there is an log_file, log_dir embedded in the
+    // document or passed via URL (could be hosted)
+    const scriptEl = document.getElementById("log_dir_context");
+    if (scriptEl) {
+      // Read the contents
+      const context = scriptEl.textContent;
+      if (context !== null) {
+        const data = JSON.parse(context);
+        if (data.log_dir || data.log_file) {
+          const log_dir = data.log_dir || dirname(data.log_file);
+          const api = simpleHttpApi(log_dir, data.log_file);
+          return clientApi(api, data.log_file);
+        }
+      }
+    }
+
+    // See if there is url params passing info (could be hosted)
+    const urlParams = new URLSearchParams(window.location.search);
+    const log_file = urlParams.get("log_file");
+    const log_dir = urlParams.get("log_dir");
+    if (log_file !== null || log_dir !== null) {
+      const resolved_log_dir = log_dir === null ? undefined : log_dir;
+      const resolved_log_file = log_file === null ? undefined : log_file;
+      const api = simpleHttpApi(resolved_log_dir, resolved_log_file);
+      return clientApi(api, resolved_log_file);
+    }
+
+    // No signal information so use the standard
+    // browser API (inspect view)
+    return clientApi(browserApi);
+  }
+};
+
+export default resolveApi();

inspect_ai/_view/www/src/api/jsonrpc.ts

@@ -0,0 +1,225 @@
+// Type definitions
+interface JsonRpcMessage {
+  jsonrpc: string;
+  id: number;
+}
+
+interface JsonRpcRequest extends JsonRpcMessage {
+  method: string;
+  params?: any;
+}
+
+interface JsonRpcResponse extends JsonRpcMessage {
+  result?: any;
+  error?: JsonRpcError;
+}
+
+interface JsonRpcError {
+  code: number;
+  message: string;
+  data?: {
+    description?: string;
+    [key: string]: any;
+  };
+}
+
+interface RequestHandlers {
+  resolve: (value: any) => void;
+  reject: (error: JsonRpcError) => void;
+}
+
+interface PostMessageTarget {
+  postMessage: (data: any) => void;
+  onMessage: (handler: (data: any) => void) => () => void;
+}
+
+// Constants
+export const kMethodEvalLogs = "eval_logs";
+export const kMethodEvalLog = "eval_log";
+export const kMethodEvalLogSize = "eval_log_size";
+export const kMethodEvalLogBytes = "eval_log_bytes";
+export const kMethodEvalLogHeaders = "eval_log_headers";
+
+export const kJsonRpcParseError = -32700;
+export const kJsonRpcInvalidRequest = -32600;
+export const kJsonRpcMethodNotFound = -32601;
+export const kJsonRpcInvalidParams = -32602;
+export const kJsonRpcInternalError = -32603;
+export const kJsonRpcVersion = "2.0";
+
+export function webViewJsonRpcClient(
+  vscode: any,
+): (method: string, params?: any) => Promise<any> {
+  const target: PostMessageTarget = {
+    postMessage: (data: any) => {
+      vscode.postMessage(data);
+    },
+    onMessage: (handler: (data: any) => void) => {
+      const onMessage = (ev: MessageEvent) => {
+        handler(ev.data);
+      };
+      window.addEventListener("message", onMessage);
+      return () => {
+        window.removeEventListener("message", onMessage);
+      };
+    },
+  };
+  return jsonRpcPostMessageRequestTransport(target).request;
+}
+
+export function jsonRpcError(
+  message: string,
+  data?: any,
+  code?: number,
+): JsonRpcError {
+  if (typeof data === "string") {
+    data = {
+      description: data,
+    };
+  }
+  return {
+    code: code || -3200,
+    message,
+    data,
+  };
+}
+
+export function asJsonRpcError(error: unknown): JsonRpcError {
+  if (typeof error === "object" && error !== null) {
+    const err = error as { message?: string; data?: any; code?: number };
+    if (typeof err.message === "string") {
+      return jsonRpcError(err.message, err.data, err.code);
+    }
+  }
+  return jsonRpcError(String(error));
+}
+
+export function jsonRpcPostMessageRequestTransport(target: PostMessageTarget) {
+  const requests = new Map<number, RequestHandlers>();
+  const disconnect = target.onMessage((ev: any) => {
+    const response = asJsonRpcResponse(ev);
+    if (response) {
+      const request = requests.get(response.id);
+      if (request) {
+        requests.delete(response.id);
+        if (response.error) {
+          request.reject(response.error);
+        } else {
+          request.resolve(response.result);
+        }
+      }
+    }
+  });
+
+  return {
+    request: (method: string, params?: any): Promise<any> => {
+      return new Promise((resolve, reject) => {
+        const requestId = Math.floor(Math.random() * 1e6);
+        requests.set(requestId, { resolve, reject });
+        const request: JsonRpcRequest = {
+          jsonrpc: kJsonRpcVersion,
+          id: requestId,
+          method,
+          params,
+        };
+        target.postMessage(request);
+      });
+    },
+    disconnect,
+  };
+}
+
+export function jsonRpcPostMessageServer(
+  target: PostMessageTarget,
+  methods:
+    | { [key: string]: (params: any) => Promise<any> }
+    | ((name: string) => ((params: any) => Promise<any>) | undefined),
+): () => void {
+  const lookupMethod =
+    typeof methods === "function" ? methods : (name: string) => methods[name];
+
+  return target.onMessage((data: any) => {
+    const request = asJsonRpcRequest(data);
+    if (request) {
+      const method = lookupMethod(request.method);
+      if (!method) {
+        target.postMessage(methodNotFoundResponse(request));
+        return;
+      }
+
+      method(request.params || [])
+        .then((value) => {
+          target.postMessage(jsonRpcResponse(request, value));
+        })
+        .catch((error) => {
+          target.postMessage({
+            jsonrpc: request.jsonrpc,
+            id: request.id,
+            error: asJsonRpcError(error),
+          });
+        });
+    }
+  });
+}
+
+function isJsonRpcMessage(message: any): message is JsonRpcMessage {
+  return message.jsonrpc !== undefined && message.id !== undefined;
+}
+
+function isJsonRpcRequest(message: JsonRpcMessage): message is JsonRpcRequest {
+  return (message as JsonRpcRequest).method !== undefined;
+}
+
+function asJsonRpcMessage(data: any): JsonRpcMessage | null {
+  if (isJsonRpcMessage(data) && data.jsonrpc === kJsonRpcVersion) {
+    return data;
+  }
+  return null;
+}
+
+function asJsonRpcRequest(data: any): JsonRpcRequest | null {
+  const message = asJsonRpcMessage(data);
+  if (message && isJsonRpcRequest(message)) {
+    return message;
+  }
+  return null;
+}
+
+function asJsonRpcResponse(data: any): JsonRpcResponse | null {
+  const message = asJsonRpcMessage(data);
+  if (message) {
+    return message as JsonRpcResponse;
+  }
+  return null;
+}
+
+function jsonRpcResponse(
+  request: JsonRpcRequest,
+  result: any,
+): JsonRpcResponse {
+  return {
+    jsonrpc: request.jsonrpc,
+    id: request.id,
+    result,
+  };
+}
+
+function jsonRpcErrorResponse(
+  request: JsonRpcRequest,
+  code: number,
+  message: string,
+): JsonRpcResponse {
+  return {
+    jsonrpc: request.jsonrpc,
+    id: request.id,
+    error: jsonRpcError(message, undefined, code),
+  };
+}
+
+function methodNotFoundResponse(request: JsonRpcRequest): JsonRpcResponse {
+  return jsonRpcErrorResponse(
+    request,
+    kJsonRpcMethodNotFound,
+    `Method '${request.method}' not found.`,
+  );
+}