@tonyclaw/agent-inspector 3.1.32 → 4.0.2

package/src/proxy/streamTiming.ts

@@ -1,31 +0,0 @@
-import type { StreamingChunk } from "./schemas";
-
-export function computeTokensPerSecond({
-  outputTokens,
-  firstChunkMs,
-  totalStreamMs,
-}: {
-  outputTokens: number | null | undefined;
-  firstChunkMs: number | null | undefined;
-  totalStreamMs: number | null | undefined;
-}): number | null {
-  if (outputTokens === null || outputTokens === undefined || outputTokens <= 0) return null;
-  if (totalStreamMs === null || totalStreamMs === undefined || totalStreamMs <= 0) return null;
-
-  const generationMs =
-    firstChunkMs === null || firstChunkMs === undefined
-      ? totalStreamMs
-      : totalStreamMs - firstChunkMs;
-  if (!Number.isFinite(generationMs) || generationMs <= 0) return null;
-
-  return Number((outputTokens / (generationMs / 1000)).toFixed(2));
-}
-
-export function firstChunkMsFromChunks(
-  chunks: readonly StreamingChunk[] | undefined,
-): number | null {
-  const first = chunks?.[0];
-  if (first === undefined) return null;
-  if (!Number.isFinite(first.timestamp) || first.timestamp < 0) return null;
-  return Math.floor(first.timestamp);
-}

package/src/proxy/toolSchemaWarnings.ts

@@ -1,529 +0,0 @@
-import type { ApiFormat } from "./schemas";
-import { isRecord, readProperty } from "../lib/unknown";
-
-type JsonObject = Record<string, unknown>;
-
-type ExpectedJsonType = "array" | "boolean" | "integer" | "null" | "number" | "object" | "string";
-
-type ParsedJson = { ok: true; value: unknown } | { ok: false };
-
-type ToolSchema = {
-  name: string;
-  schema: JsonObject | null;
-};
-
-type ToolCall = {
-  name: string | null;
-  arguments: unknown;
-  argumentIssue: string | null;
-  location: string;
-};
-
-export type ToolSchemaWarningInput = {
-  rawRequestBody: string | null;
-  responseText: string | null;
-  apiFormat: ApiFormat;
-};
-
-function parseJson(raw: string | null): ParsedJson {
-  if (raw === null) return { ok: false };
-  try {
-    return { ok: true, value: JSON.parse(raw) };
-  } catch {
-    return { ok: false };
-  }
-}
-
-function hasOwnProperty(value: JsonObject, key: string): boolean {
-  return Object.getOwnPropertyDescriptor(value, key) !== undefined;
-}
-
-function readString(value: unknown, key: string): string | null {
-  const property = readProperty(value, key);
-  return typeof property === "string" ? property : null;
-}
-
-function readArray(value: unknown, key: string): unknown[] {
-  const property = readProperty(value, key);
-  return Array.isArray(property) ? property : [];
-}
-
-function readStringArray(value: unknown, key: string): string[] {
-  return readArray(value, key).filter((item): item is string => typeof item === "string");
-}
-
-function readObject(value: unknown, key: string): JsonObject | null {
-  const property = readProperty(value, key);
-  return isRecord(property) ? property : null;
-}
-
-function normalizeExpectedType(typeName: string): ExpectedJsonType | null {
-  switch (typeName) {
-    case "array":
-    case "boolean":
-    case "integer":
-    case "null":
-    case "number":
-    case "object":
-    case "string":
-      return typeName;
-    default:
-      return null;
-  }
-}
-
-function schemaTypes(schema: JsonObject): ExpectedJsonType[] {
-  const typeValue = readProperty(schema, "type");
-  const rawTypes = Array.isArray(typeValue) ? typeValue : [typeValue];
-  const types: ExpectedJsonType[] = [];
-  for (const rawType of rawTypes) {
-    if (typeof rawType !== "string") continue;
-    const normalized = normalizeExpectedType(rawType);
-    if (normalized !== null && !types.includes(normalized)) {
-      types.push(normalized);
-    }
-  }
-  return types;
-}
-
-function actualType(value: unknown): ExpectedJsonType | "undefined" | "unknown" {
-  if (value === null) return "null";
-  if (Array.isArray(value)) return "array";
-
-  switch (typeof value) {
-    case "boolean":
-      return "boolean";
-    case "number":
-      return Number.isInteger(value) ? "integer" : "number";
-    case "string":
-      return "string";
-    case "undefined":
-      return "undefined";
-    case "bigint":
-    case "function":
-    case "object":
-    case "symbol":
-      return isRecord(value) ? "object" : "unknown";
-  }
-  return "unknown";
-}
-
-function matchesExpectedType(value: unknown, expected: ExpectedJsonType): boolean {
-  switch (expected) {
-    case "array":
-      return Array.isArray(value);
-    case "boolean":
-      return typeof value === "boolean";
-    case "integer":
-      return typeof value === "number" && Number.isInteger(value);
-    case "null":
-      return value === null;
-    case "number":
-      return typeof value === "number" && Number.isFinite(value);
-    case "object":
-      return isRecord(value);
-    case "string":
-      return typeof value === "string";
-  }
-}
-
-function matchesAnyExpectedType(
-  value: unknown,
-  expectedTypes: readonly ExpectedJsonType[],
-): boolean {
-  return expectedTypes.some((expected) => matchesExpectedType(value, expected));
-}
-
-function formatExpectedTypes(expectedTypes: readonly ExpectedJsonType[]): string {
-  return expectedTypes.join(" or ");
-}
-
-function pathLabel(path: string): string {
-  return path === "" ? "arguments" : `argument "${path}"`;
-}
-
-function childPath(parent: string, key: string): string {
-  return parent === "" ? key : `${parent}.${key}`;
-}
-
-function jsonString(value: unknown): string | null {
-  try {
-    const serialized = JSON.stringify(value);
-    return serialized === undefined ? null : serialized;
-  } catch {
-    return null;
-  }
-}
-
-function jsonValuesEqual(left: unknown, right: unknown): boolean {
-  const leftJson = jsonString(left);
-  const rightJson = jsonString(right);
-  return leftJson !== null && rightJson !== null && leftJson === rightJson;
-}
-
-function formatJsonValue(value: unknown): string {
-  const serialized = jsonString(value);
-  return serialized ?? String(value);
-}
-
-function enumMatches(value: unknown, enumValues: readonly unknown[]): boolean {
-  return enumValues.some((enumValue) => jsonValuesEqual(value, enumValue));
-}
-
-function schemaHasObjectKeywords(schema: JsonObject): boolean {
-  return (
-    readStringArray(schema, "required").length > 0 || readObject(schema, "properties") !== null
-  );
-}
-
-function schemaAllowsObjectValidation(
-  schema: JsonObject,
-  expectedTypes: readonly ExpectedJsonType[],
-): boolean {
-  if (expectedTypes.length === 0) return schemaHasObjectKeywords(schema);
-  return expectedTypes.includes("object");
-}
-
-function schemaAllowsArrayValidation(
-  schema: JsonObject,
-  expectedTypes: readonly ExpectedJsonType[],
-): boolean {
-  if (expectedTypes.length === 0) return readProperty(schema, "items") !== undefined;
-  return expectedTypes.includes("array");
-}
-
-function addTypeWarning(
-  warnings: string[],
-  toolName: string,
-  path: string,
-  expectedTypes: readonly ExpectedJsonType[],
-  value: unknown,
-): void {
-  warnings.push(
-    `Tool call "${toolName}" ${pathLabel(path)} expected ${formatExpectedTypes(
-      expectedTypes,
-    )} but got ${actualType(value)}.`,
-  );
-}
-
-function validateObjectSchema(
-  schema: JsonObject,
-  value: JsonObject,
-  toolName: string,
-  path: string,
-  warnings: string[],
-): void {
-  for (const requiredName of readStringArray(schema, "required")) {
-    if (!hasOwnProperty(value, requiredName)) {
-      warnings.push(
-        `Tool call "${toolName}" is missing required ${pathLabel(childPath(path, requiredName))}.`,
-      );
-    }
-  }
-
-  const properties = readObject(schema, "properties");
-  if (properties === null) return;
-  for (const [propertyName, propertySchema] of Object.entries(properties)) {
-    const descriptor = Object.getOwnPropertyDescriptor(value, propertyName);
-    if (descriptor === undefined) continue;
-    validateValueAgainstSchema(
-      propertySchema,
-      descriptor.value,
-      toolName,
-      childPath(path, propertyName),
-      warnings,
-    );
-  }
-}
-
-function validateArraySchema(
-  schema: JsonObject,
-  value: readonly unknown[],
-  toolName: string,
-  path: string,
-  warnings: string[],
-): void {
-  const itemsSchema = readProperty(schema, "items");
-  if (itemsSchema === undefined) return;
-  let index = 0;
-  for (const item of value) {
-    validateValueAgainstSchema(itemsSchema, item, toolName, `${path}[${index}]`, warnings);
-    index++;
-  }
-}
-
-function validateEnum(
-  schema: JsonObject,
-  value: unknown,
-  toolName: string,
-  path: string,
-  warnings: string[],
-): void {
-  const enumValue = readProperty(schema, "enum");
-  if (Array.isArray(enumValue) && enumValue.length > 0 && !enumMatches(value, enumValue)) {
-    warnings.push(
-      `Tool call "${toolName}" ${pathLabel(path)} expected one of ${formatJsonValue(
-        enumValue,
-      )} but got ${formatJsonValue(value)}.`,
-    );
-  }
-
-  const constDescriptor = Object.getOwnPropertyDescriptor(schema, "const");
-  if (constDescriptor !== undefined && !jsonValuesEqual(value, constDescriptor.value)) {
-    warnings.push(
-      `Tool call "${toolName}" ${pathLabel(path)} expected ${formatJsonValue(
-        constDescriptor.value,
-      )} but got ${formatJsonValue(value)}.`,
-    );
-  }
-}
-
-function validateValueAgainstSchema(
-  schema: unknown,
-  value: unknown,
-  toolName: string,
-  path: string,
-  warnings: string[],
-): void {
-  if (!isRecord(schema)) return;
-
-  const expectedTypes = schemaTypes(schema);
-  if (expectedTypes.length > 0 && !matchesAnyExpectedType(value, expectedTypes)) {
-    addTypeWarning(warnings, toolName, path, expectedTypes, value);
-    return;
-  }
-
-  validateEnum(schema, value, toolName, path, warnings);
-
-  if (schemaAllowsObjectValidation(schema, expectedTypes)) {
-    if (isRecord(value)) {
-      validateObjectSchema(schema, value, toolName, path, warnings);
-    } else if (expectedTypes.length === 0) {
-      warnings.push(
-        `Tool call "${toolName}" ${pathLabel(path)} expected object but got ${actualType(value)}.`,
-      );
-    }
-  }
-
-  if (schemaAllowsArrayValidation(schema, expectedTypes)) {
-    if (Array.isArray(value)) {
-      validateArraySchema(schema, value, toolName, path, warnings);
-    } else if (expectedTypes.length === 0) {
-      warnings.push(
-        `Tool call "${toolName}" ${pathLabel(path)} expected array but got ${actualType(value)}.`,
-      );
-    }
-  }
-}
-
-function extractAnthropicToolSchemas(request: unknown): Map<string, ToolSchema> {
-  const tools = new Map<string, ToolSchema>();
-  for (const tool of readArray(request, "tools")) {
-    if (!isRecord(tool)) continue;
-    const name = readString(tool, "name");
-    if (name === null || name === "") continue;
-    tools.set(name, {
-      name,
-      schema: readObject(tool, "input_schema"),
-    });
-  }
-  return tools;
-}
-
-function extractOpenAIToolSchemas(request: unknown): Map<string, ToolSchema> {
-  const tools = new Map<string, ToolSchema>();
-  for (const tool of readArray(request, "tools")) {
-    const functionDefinition = readObject(tool, "function");
-    const name =
-      functionDefinition === null
-        ? readString(tool, "name")
-        : (readString(functionDefinition, "name") ?? readString(tool, "name"));
-    if (name === null || name === "") continue;
-    const parameters =
-      functionDefinition === null
-        ? readObject(tool, "parameters")
-        : (readObject(functionDefinition, "parameters") ?? readObject(tool, "parameters"));
-    tools.set(name, {
-      name,
-      schema: parameters,
-    });
-  }
-  return tools;
-}
-
-function mergeToolSchemas(
-  primary: Map<string, ToolSchema>,
-  secondary: Map<string, ToolSchema>,
-): Map<string, ToolSchema> {
-  const merged = new Map(primary);
-  for (const [name, schema] of secondary) {
-    if (!merged.has(name)) merged.set(name, schema);
-  }
-  return merged;
-}
-
-function extractToolSchemas(request: unknown, apiFormat: ApiFormat): Map<string, ToolSchema> {
-  switch (apiFormat) {
-    case "anthropic":
-      return extractAnthropicToolSchemas(request);
-    case "openai":
-      return extractOpenAIToolSchemas(request);
-    case "unknown":
-      return mergeToolSchemas(
-        extractOpenAIToolSchemas(request),
-        extractAnthropicToolSchemas(request),
-      );
-  }
-}
-
-function parseOpenAIArguments(argumentsValue: unknown): { value: unknown; issue: string | null } {
-  if (argumentsValue === undefined) {
-    return { value: {}, issue: "arguments field is missing" };
-  }
-  if (typeof argumentsValue !== "string") {
-    return { value: argumentsValue, issue: null };
-  }
-  try {
-    return { value: JSON.parse(argumentsValue), issue: null };
-  } catch {
-    return { value: {}, issue: "arguments are not valid JSON" };
-  }
-}
-
-function extractOpenAIToolCalls(response: unknown): ToolCall[] {
-  const calls: ToolCall[] = [];
-  let choiceIndex = 0;
-  for (const choice of readArray(response, "choices")) {
-    const message = readObject(choice, "message");
-    if (message === null) {
-      choiceIndex++;
-      continue;
-    }
-
-    let callIndex = 0;
-    for (const call of readArray(message, "tool_calls")) {
-      const functionCall = readObject(call, "function");
-      const name = functionCall === null ? null : readString(functionCall, "name");
-      const parsedArguments =
-        functionCall === null
-          ? { value: {}, issue: "function block is missing" }
-          : parseOpenAIArguments(readProperty(functionCall, "arguments"));
-      calls.push({
-        name,
-        arguments: parsedArguments.value,
-        argumentIssue: parsedArguments.issue,
-        location: `choices[${choiceIndex}].message.tool_calls[${callIndex}]`,
-      });
-      callIndex++;
-    }
-
-    const legacyFunctionCall = readObject(message, "function_call");
-    if (legacyFunctionCall !== null) {
-      const parsedArguments = parseOpenAIArguments(readProperty(legacyFunctionCall, "arguments"));
-      calls.push({
-        name: readString(legacyFunctionCall, "name"),
-        arguments: parsedArguments.value,
-        argumentIssue: parsedArguments.issue,
-        location: `choices[${choiceIndex}].message.function_call`,
-      });
-    }
-    choiceIndex++;
-  }
-
-  let outputIndex = 0;
-  for (const item of readArray(response, "output")) {
-    if (readString(item, "type") !== "function_call") {
-      outputIndex++;
-      continue;
-    }
-    const parsedArguments = parseOpenAIArguments(readProperty(item, "arguments"));
-    calls.push({
-      name: readString(item, "name"),
-      arguments: parsedArguments.value,
-      argumentIssue: parsedArguments.issue,
-      location: `output[${outputIndex}]`,
-    });
-    outputIndex++;
-  }
-  return calls;
-}
-
-function extractAnthropicToolCalls(response: unknown): ToolCall[] {
-  const calls: ToolCall[] = [];
-  let contentIndex = 0;
-  for (const block of readArray(response, "content")) {
-    if (readString(block, "type") !== "tool_use") {
-      contentIndex++;
-      continue;
-    }
-    calls.push({
-      name: readString(block, "name"),
-      arguments: readProperty(block, "input") ?? {},
-      argumentIssue: null,
-      location: `content[${contentIndex}]`,
-    });
-    contentIndex++;
-  }
-  return calls;
-}
-
-function extractToolCalls(response: unknown, apiFormat: ApiFormat): ToolCall[] {
-  switch (apiFormat) {
-    case "anthropic":
-      return extractAnthropicToolCalls(response);
-    case "openai":
-      return extractOpenAIToolCalls(response);
-    case "unknown":
-      return [...extractOpenAIToolCalls(response), ...extractAnthropicToolCalls(response)];
-  }
-}
-
-function uniqueWarnings(warnings: readonly string[]): string[] {
-  const seen = new Set<string>();
-  const unique: string[] = [];
-  for (const warning of warnings) {
-    if (seen.has(warning)) continue;
-    seen.add(warning);
-    unique.push(warning);
-  }
-  return unique;
-}
-
-export function analyzeToolSchemaWarnings(input: ToolSchemaWarningInput): string[] {
-  const request = parseJson(input.rawRequestBody);
-  const response = parseJson(input.responseText);
-  if (!request.ok || !response.ok) return [];
-
-  const toolSchemas = extractToolSchemas(request.value, input.apiFormat);
-  const toolCalls = extractToolCalls(response.value, input.apiFormat);
-  if (toolCalls.length === 0) return [];
-
-  const warnings: string[] = [];
-  for (const call of toolCalls) {
-    if (call.name === null || call.name === "") {
-      warnings.push(`Tool call at ${call.location} is missing a tool name.`);
-      continue;
-    }
-
-    const schema = toolSchemas.get(call.name);
-    if (schema === undefined) {
-      warnings.push(
-        toolSchemas.size === 0
-          ? `Tool call "${call.name}" was returned, but the request did not define any tools.`
-          : `Tool call "${call.name}" was returned, but it is not defined in the request tools.`,
-      );
-      continue;
-    }
-
-    if (call.argumentIssue !== null) {
-      warnings.push(`Tool call "${call.name}" ${call.argumentIssue}.`);
-      continue;
-    }
-
-    if (schema.schema !== null) {
-      validateValueAgainstSchema(schema.schema, call.arguments, schema.name, "", warnings);
-    }
-  }
-
-  return uniqueWarnings(warnings);
-}

package/src/proxy/uiAssetServer.ts

@@ -1,106 +0,0 @@
-import { Buffer } from "node:buffer";
-import { readFile } from "node:fs/promises";
-import { extname, relative, resolve, sep } from "node:path";
-
-const CONTENT_TYPES: Readonly<Record<string, string>> = {
-  ".css": "text/css; charset=utf-8",
-  ".html": "text/html; charset=utf-8",
-  ".ico": "image/x-icon",
-  ".jpeg": "image/jpeg",
-  ".jpg": "image/jpeg",
-  ".js": "text/javascript; charset=utf-8",
-  ".json": "application/json; charset=utf-8",
-  ".map": "application/json; charset=utf-8",
-  ".png": "image/png",
-  ".svg": "image/svg+xml",
-  ".webp": "image/webp",
-  ".woff": "font/woff",
-  ".woff2": "font/woff2",
-};
-
-export type UiAsset = {
-  body: Buffer;
-  cacheControl: string;
-  contentType: string;
-  document: boolean;
-};
-
-function safeDecodedPath(pathname: string): string | null {
-  let decoded: string;
-  try {
-    decoded = decodeURIComponent(pathname);
-  } catch {
-    return null;
-  }
-  if (decoded.includes("\\") || decoded.includes("\0")) return null;
-  if (decoded.split("/").some((segment) => segment === "." || segment === "..")) return null;
-  return decoded;
-}
-
-function isInsideDirectory(path: string, directory: string): boolean {
-  const child = relative(directory, path);
-  return child === "" || (!child.startsWith("..") && !child.startsWith(sep));
-}
-
-function assetPath(uiDirectory: string, pathname: string): string | null {
-  const decoded = safeDecodedPath(pathname);
-  if (decoded === null) return null;
-  const target = resolve(uiDirectory, `.${decoded}`);
-  return isInsideDirectory(target, resolve(uiDirectory)) ? target : null;
-}
-
-async function readAsset(path: string): Promise<Buffer | null> {
-  try {
-    return await readFile(path);
-  } catch {
-    return null;
-  }
-}
-
-function contentTypeFor(path: string): string {
-  return CONTENT_TYPES[extname(path).toLowerCase()] ?? "application/octet-stream";
-}
-
-function isBackendNamespace(pathname: string): boolean {
-  return (
-    pathname === "/api" ||
-    pathname.startsWith("/api/") ||
-    pathname === "/proxy" ||
-    pathname.startsWith("/proxy/") ||
-    pathname === "/livez" ||
-    pathname === "/readyz"
-  );
-}
-
-function shouldUseDocumentFallback(pathname: string): boolean {
-  if (pathname === "/" || pathname.length === 0) return true;
-  const lastSegment = pathname.split("/").at(-1) ?? "";
-  return !lastSegment.includes(".");
-}
-
-export async function loadUiAsset(uiDirectory: string, pathname: string): Promise<UiAsset | null> {
-  if (isBackendNamespace(pathname)) return null;
-  const requestedPath = assetPath(uiDirectory, pathname);
-  if (requestedPath === null) return null;
-  const requestedBody = await readAsset(requestedPath);
-  if (requestedBody !== null) {
-    return {
-      body: requestedBody,
-      cacheControl: pathname.startsWith("/assets/")
-        ? "public, max-age=31536000, immutable"
-        : "no-cache",
-      contentType: contentTypeFor(requestedPath),
-      document: extname(requestedPath).toLowerCase() === ".html",
-    };
-  }
-  if (!shouldUseDocumentFallback(pathname)) return null;
-  const indexPath = resolve(uiDirectory, "index.html");
-  const indexBody = await readAsset(indexPath);
-  if (indexBody === null) return null;
-  return {
-    body: indexBody,
-    cacheControl: "no-store",
-    contentType: CONTENT_TYPES[".html"] ?? "text/html; charset=utf-8",
-    document: true,
-  };
-}