@tonyclaw/agent-inspector 2.0.24 → 2.0.26

package/src/components/providers/ProviderForm.tsx

@@ -1,9 +1,11 @@
 import { type JSX, useState, useEffect, useRef } from "react";
 import { Button } from "../ui/button";
+import { Select, SelectContent, SelectItem, SelectTrigger, SelectValue } from "../ui/select";
 import { Tooltip, TooltipTrigger, TooltipContent, TooltipProvider } from "../ui/tooltip";
 import { Eye, EyeOff, Copy, Check, ChevronDown } from "lucide-react";
 import type { ProviderConfig, ProviderModelMetadata } from "../../lib/providerContract";
 import { maskApiKey } from "../../lib/mask";
+import { formatContextWindowInput, parseContextWindowTokensInput } from "../../lib/utils";
 
 const ZHIPU_PROVIDER_KEYWORDS = ["zhipu", "zhipuai", "bigmodel", "z.ai", "zai", "glm"];
 const ZHIPU_CODING_PROVIDER_KEYWORDS = [
@@ -129,11 +131,29 @@ type ProviderFormProps = {
 
 type ModelMetadataDraft = {
   contextWindow: string;
+  contextWindowMode: ContextWindowMode;
   outputLimit: string;
 };
 
+type ContextWindowMode = "unset" | "preset" | "custom";
+
+type ContextWindowUnit = "K" | "M" | "tokens";
+
+const CONTEXT_WINDOW_UNSET = "__unset__";
+const CONTEXT_WINDOW_CUSTOM = "__custom__";
+
+const CONTEXT_WINDOW_PRESETS = [
+  { value: "32K", label: "Small" },
+  { value: "64K", label: "Standard" },
+  { value: "128K", label: "Medium" },
+  { value: "200K", label: "Long" },
+  { value: "256K", label: "Extended" },
+  { value: "512K", label: "Large" },
+  { value: "1M", label: "Max" },
+];
+
 function emptyMetadataDraft(): ModelMetadataDraft {
-  return { contextWindow: "", outputLimit: "" };
+  return { contextWindow: "", contextWindowMode: "unset", outputLimit: "" };
 }
 
 function normalizeModelName(value: string): string {
@@ -152,14 +172,74 @@ function findModelMetadata(
   );
 }
 
+function findContextWindowPreset(value: string): string | null {
+  const tokens = parseContextWindowTokensInput(value);
+  if (tokens === null) return null;
+  for (const preset of CONTEXT_WINDOW_PRESETS) {
+    if (parseContextWindowTokensInput(preset.value) === tokens) return preset.value;
+  }
+  return null;
+}
+
+function contextWindowModeForValue(value: string): ContextWindowMode {
+  if (value.trim() === "") return "unset";
+  return findContextWindowPreset(value) !== null ? "preset" : "custom";
+}
+
+function selectedContextWindowPresetValue(draft: ModelMetadataDraft): string {
+  switch (draft.contextWindowMode) {
+    case "unset":
+      return CONTEXT_WINDOW_UNSET;
+    case "custom":
+      return CONTEXT_WINDOW_CUSTOM;
+    case "preset":
+      return findContextWindowPreset(draft.contextWindow) ?? CONTEXT_WINDOW_CUSTOM;
+  }
+}
+
+function splitContextWindowEditorValue(value: string): { amount: string; unit: ContextWindowUnit } {
+  const trimmed = value.trim().replaceAll(",", "");
+  if (trimmed === "") return { amount: "", unit: "K" };
+  const match = /^(\d+(?:\.\d+)?)\s*([kKmM])?$/.exec(trimmed);
+  if (match === null) return { amount: trimmed, unit: "K" };
+  const amount = match[1];
+  if (amount === undefined) return { amount: trimmed, unit: "K" };
+  const unit = match[2];
+  if (unit === undefined || unit === "") return { amount, unit: "tokens" };
+  switch (unit.toLowerCase()) {
+    case "k":
+      return { amount, unit: "K" };
+    case "m":
+      return { amount, unit: "M" };
+    default:
+      return { amount: trimmed, unit: "K" };
+  }
+}
+
+function joinContextWindowEditorValue(amount: string, unit: ContextWindowUnit): string {
+  const trimmed = amount.trim();
+  if (trimmed === "") return "";
+  switch (unit) {
+    case "K":
+      return `${trimmed}K`;
+    case "M":
+      return `${trimmed}M`;
+    case "tokens":
+      return trimmed;
+  }
+}
+
 function createMetadataDrafts(
   provider: ProviderConfig | undefined,
   models: readonly string[],
 ): ModelMetadataDraft[] {
   return models.map((model) => {
     const metadata = findModelMetadata(provider, model);
+    const contextWindow =
+      metadata?.contextWindow !== undefined ? formatContextWindowInput(metadata.contextWindow) : "";
     return {
-      contextWindow: metadata?.contextWindow?.toString() ?? "",
+      contextWindow,
+      contextWindowMode: contextWindowModeForValue(contextWindow),
       outputLimit: metadata?.outputLimit?.toString() ?? "",
     };
   });
@@ -315,11 +395,11 @@ export function ProviderForm({ provider, onSubmit, onCancel }: ProviderFormProps
       newErrors.modelMetadataUrl = "Invalid URL format";
     }
     modelMetadataDrafts.forEach((draft, index) => {
-      const contextWindow = readPositiveIntegerInput(draft.contextWindow);
+      const contextWindow = parseContextWindowTokensInput(draft.contextWindow);
       const outputLimit = readPositiveIntegerInput(draft.outputLimit);
       if (draft.contextWindow.trim() !== "" && contextWindow === null) {
         newErrors[`modelMetadata.${index}.contextWindow`] =
-          "Context window must be a positive integer";
+          "Context window must be a positive number, optionally using K or M";
       }
       if (draft.outputLimit.trim() !== "" && outputLimit === null) {
         newErrors[`modelMetadata.${index}.outputLimit`] = "Output limit must be a positive integer";
@@ -361,6 +441,51 @@ export function ProviderForm({ provider, onSubmit, onCancel }: ProviderFormProps
     });
   }
 
+  function updateContextWindowPreset(index: number, value: string): void {
+    switch (value) {
+      case CONTEXT_WINDOW_UNSET:
+        updateMetadataDraft(index, { contextWindow: "", contextWindowMode: "unset" });
+        return;
+      case CONTEXT_WINDOW_CUSTOM: {
+        const current = modelMetadataDrafts[index] ?? emptyMetadataDraft();
+        updateMetadataDraft(index, {
+          contextWindow: current.contextWindow,
+          contextWindowMode: "custom",
+        });
+        return;
+      }
+      default:
+        updateMetadataDraft(index, { contextWindow: value, contextWindowMode: "preset" });
+        return;
+    }
+  }
+
+  function updateContextWindowAmount(index: number, amount: string): void {
+    const current = modelMetadataDrafts[index] ?? emptyMetadataDraft();
+    const editorValue = splitContextWindowEditorValue(current.contextWindow);
+    updateMetadataDraft(index, {
+      contextWindow: joinContextWindowEditorValue(amount, editorValue.unit),
+      contextWindowMode: "custom",
+    });
+  }
+
+  function updateContextWindowUnit(index: number, unit: string): void {
+    const current = modelMetadataDrafts[index] ?? emptyMetadataDraft();
+    const editorValue = splitContextWindowEditorValue(current.contextWindow);
+    switch (unit) {
+      case "K":
+      case "M":
+      case "tokens":
+        updateMetadataDraft(index, {
+          contextWindow: joinContextWindowEditorValue(editorValue.amount, unit),
+          contextWindowMode: "custom",
+        });
+        return;
+      default:
+        return;
+    }
+  }
+
   function removeModel(index: number): void {
     setModels((prev) => prev.filter((_, idx) => idx !== index));
     setModelMetadataDrafts((prev) => prev.filter((_, idx) => idx !== index));
@@ -379,7 +504,7 @@ export function ProviderForm({ provider, onSubmit, onCancel }: ProviderFormProps
       const trimmedModel = model.trim();
       if (trimmedModel === "") return;
       const draft = modelMetadataDrafts[index] ?? emptyMetadataDraft();
-      const contextWindow = readPositiveIntegerInput(draft.contextWindow);
+      const contextWindow = parseContextWindowTokensInput(draft.contextWindow);
       const outputLimit = readPositiveIntegerInput(draft.outputLimit);
       if (contextWindow === null && outputLimit === null) return;
 
@@ -548,6 +673,8 @@ export function ProviderForm({ provider, onSubmit, onCancel }: ProviderFormProps
           const draft = modelMetadataDrafts[i] ?? emptyMetadataDraft();
           const contextWindowError = errors[`modelMetadata.${i}.contextWindow`];
           const outputLimitError = errors[`modelMetadata.${i}.outputLimit`];
+          const contextWindowPresetValue = selectedContextWindowPresetValue(draft);
+          const contextWindowEditorValue = splitContextWindowEditorValue(draft.contextWindow);
           return (
             <div
               key={i}
@@ -624,21 +751,54 @@ export function ProviderForm({ provider, onSubmit, onCancel }: ProviderFormProps
               </div>
 
               <div className="grid gap-2 sm:grid-cols-2">
-                <label className="space-y-1 text-xs text-muted-foreground">
+                <div className="space-y-1 text-xs text-muted-foreground">
                   <span>Context Window</span>
-                  <input
-                    type="number"
-                    min={1}
-                    step={1000}
-                    value={draft.contextWindow}
-                    onChange={(e) => updateMetadataDraft(i, { contextWindow: e.target.value })}
-                    placeholder="e.g. 1048576"
-                    className="w-full rounded-md border border-input bg-background px-3 py-2 font-mono text-xs text-foreground ring-offset-background placeholder:text-muted-foreground focus-visible:border-ring focus-visible:outline-ring focus-visible:ring-[3px]"
-                  />
+                  <Select
+                    value={contextWindowPresetValue}
+                    onValueChange={(value) => updateContextWindowPreset(i, value)}
+                  >
+                    <SelectTrigger size="sm" className="w-full bg-background font-mono text-xs">
+                      <SelectValue />
+                    </SelectTrigger>
+                    <SelectContent className="max-h-64">
+                      <SelectItem value={CONTEXT_WINDOW_UNSET}>Not set</SelectItem>
+                      {CONTEXT_WINDOW_PRESETS.map((preset) => (
+                        <SelectItem key={preset.value} value={preset.value}>
+                          {preset.label} · {preset.value}
+                        </SelectItem>
+                      ))}
+                      <SelectItem value={CONTEXT_WINDOW_CUSTOM}>Custom</SelectItem>
+                    </SelectContent>
+                  </Select>
+                  {draft.contextWindowMode === "custom" && (
+                    <div className="grid grid-cols-[minmax(0,1fr)_5.75rem] gap-1.5">
+                      <input
+                        type="text"
+                        inputMode="decimal"
+                        value={contextWindowEditorValue.amount}
+                        onChange={(e) => updateContextWindowAmount(i, e.target.value)}
+                        placeholder="128"
+                        className="w-full rounded-md border border-input bg-background px-3 py-2 font-mono text-xs text-foreground ring-offset-background placeholder:text-muted-foreground focus-visible:border-ring focus-visible:outline-ring focus-visible:ring-[3px]"
+                      />
+                      <Select
+                        value={contextWindowEditorValue.unit}
+                        onValueChange={(value) => updateContextWindowUnit(i, value)}
+                      >
+                        <SelectTrigger size="sm" className="w-full bg-background font-mono text-xs">
+                          <SelectValue />
+                        </SelectTrigger>
+                        <SelectContent>
+                          <SelectItem value="K">K</SelectItem>
+                          <SelectItem value="M">M</SelectItem>
+                          <SelectItem value="tokens">tokens</SelectItem>
+                        </SelectContent>
+                      </Select>
+                    </div>
+                  )}
                   {contextWindowError !== undefined && (
                     <span className="block text-destructive">{contextWindowError}</span>
                   )}
-                </label>
+                </div>
                 <label className="space-y-1 text-xs text-muted-foreground">
                   <span>Output Limit</span>
                   <input

package/src/lib/sessionInfoContract.ts

@@ -0,0 +1,69 @@
+import { z } from "zod";
+
+export const SessionTokenUsageSchema = z.object({
+  input: z.number().int().nonnegative(),
+  output: z.number().int().nonnegative(),
+  cacheCreate: z.number().int().nonnegative(),
+  cacheRead: z.number().int().nonnegative(),
+  total: z.number().int().nonnegative(),
+});
+
+export const SessionLogSummarySchema = z.object({
+  id: z.number().int().positive(),
+  timestamp: z.string(),
+  provider: z.string().nullable(),
+  model: z.string().nullable(),
+  apiFormat: z.enum(["anthropic", "openai", "unknown"]),
+  method: z.string(),
+  path: z.string(),
+  status: z.number().nullable(),
+  isStreaming: z.boolean(),
+  hasError: z.boolean(),
+  error: z.string().nullable(),
+  latencyMs: z.number().nullable(),
+  tokens: z.object({
+    input: z.number().nullable(),
+    output: z.number().nullable(),
+    cacheCreate: z.number().nullable(),
+    cacheRead: z.number().nullable(),
+  }),
+  sessionId: z.string().nullable(),
+});
+
+export const SessionInfoSchema = z.object({
+  id: z.string(),
+  status: z.enum(["active", "failed", "completed", "empty"]),
+  logCoverage: z.enum(["recent", "history"]),
+  source: z.enum(["explicit", "client-process", "client-connection", "provider-test"]).nullable(),
+  runtimeMode: z.enum(["in-process", "worker-thread", "child-process"]).nullable(),
+  createdAt: z.string().nullable(),
+  updatedAt: z.string().nullable(),
+  requestCount: z.number().int().nonnegative(),
+  activeRequests: z.number().int().nonnegative(),
+  completedRequests: z.number().int().nonnegative(),
+  failedRequests: z.number().int().nonnegative(),
+  queuedTasks: z.number().int().nonnegative(),
+  runningTasks: z.number().int().nonnegative(),
+  lastTaskError: z.string().nullable(),
+  logCount: z.number().int().nonnegative(),
+  errorCount: z.number().int().nonnegative(),
+  models: z.array(z.string()),
+  providers: z.array(z.string()),
+  tokenUsage: SessionTokenUsageSchema,
+  lastLogId: z.number().nullable(),
+  lastModel: z.string().nullable(),
+  clientPid: z.number().nullable(),
+  clientProjectFolder: z.string().nullable(),
+  inspectorPath: z.string(),
+  inspectorUrl: z.string(),
+  apiPath: z.string(),
+  apiUrl: z.string(),
+  compactLogsPath: z.string(),
+  compactLogsUrl: z.string(),
+  latestLogLimit: z.number().int().positive(),
+  latestLogs: z.array(SessionLogSummarySchema),
+});
+
+export type SessionTokenUsage = z.infer<typeof SessionTokenUsageSchema>;
+export type SessionLogSummary = z.infer<typeof SessionLogSummarySchema>;
+export type SessionInfo = z.infer<typeof SessionInfoSchema>;

package/src/lib/utils.ts

@@ -17,6 +17,52 @@ export function formatContextWindowTokens(count: number): string {
   return (count / 1024).toFixed(1).replace(/\.0$/, "") + "K";
 }
 
+function formatExactContextUnit(count: number, multiplier: number, unit: "K" | "M"): string | null {
+  const tenths = count * 10;
+  if (!Number.isSafeInteger(tenths) || tenths % multiplier !== 0) return null;
+  return (tenths / multiplier / 10).toFixed(1).replace(/\.0$/, "") + unit;
+}
+
+export function formatContextWindowInput(count: number): string {
+  if (!Number.isSafeInteger(count) || count <= 0) return count.toString();
+  if (count >= 1024 * 1024) {
+    const megaValue = formatExactContextUnit(count, 1024 * 1024, "M");
+    if (megaValue !== null) return megaValue;
+  }
+  const kiloValue = formatExactContextUnit(count, 1024, "K");
+  if (kiloValue !== null) return kiloValue;
+  return count.toString();
+}
+
+function contextWindowUnitMultiplier(unit: string | undefined): number | null {
+  if (unit === undefined || unit === "") return 1;
+  switch (unit.toLowerCase()) {
+    case "k":
+      return 1024;
+    case "m":
+      return 1024 * 1024;
+    default:
+      return null;
+  }
+}
+
+export function parseContextWindowTokensInput(value: string): number | null {
+  const trimmed = value.trim().replaceAll(",", "");
+  if (trimmed === "") return null;
+  const match = /^(\d+(?:\.\d+)?)\s*([kKmM])?$/.exec(trimmed);
+  if (match === null) return null;
+  const amountText = match[1];
+  if (amountText === undefined) return null;
+  const amount = Number(amountText);
+  const unit = match[2];
+  const multiplier = contextWindowUnitMultiplier(unit);
+  if (!Number.isFinite(amount) || amount <= 0 || multiplier === null) return null;
+  if ((unit === undefined || unit === "") && !Number.isInteger(amount)) return null;
+  const tokens = Math.round(amount * multiplier);
+  if (!Number.isSafeInteger(tokens) || tokens <= 0) return null;
+  return tokens;
+}
+
 export type StatusCategory = "success" | "client_error" | "server_error" | "pending";
 
 export function getStatusCategory(status: number | null): StatusCategory {

package/src/mcp/server.ts

@@ -23,6 +23,7 @@ import {
   addProviderImpl,
   createSessionKnowledgeImpl,
   getProjectContextImpl,
+  getSessionImpl,
   getLogChunksImpl,
   getLogImpl,
   getProviderImpl,
@@ -201,6 +202,30 @@ function registerTools(server: McpServer): void {
     () => safeCall(() => listSessionsImpl(callApi)),
   );
 
+  server.registerTool(
+    "inspector_get_session",
+    {
+      title: "Get Inspector session info",
+      description:
+        "Returns a lightweight, evidence-friendly summary for one Inspector session: clickable inspectorUrl, compact logs URL, status, request/error counts, token totals, models/providers, and the latest compact log summaries. Defaults to recent in-memory/cache data for speed; set includeHistory=true only when you explicitly want to scan persisted jsonl history. It avoids raw request/response bodies so it is safe to use in evaluation artifacts.",
+      inputSchema: z.object({
+        sessionId: z.string().min(1).describe("The Inspector session id."),
+        includeHistory: z
+          .boolean()
+          .optional()
+          .describe("Scan persisted jsonl history for this session. Slower; default false."),
+        latestLogLimit: z
+          .number()
+          .int()
+          .positive()
+          .max(50)
+          .optional()
+          .describe("How many latest compact log summaries to include. Max 50, default 10."),
+      }),
+    },
+    (args) => safeCall(() => getSessionImpl(callApi, args)),
+  );
+
   server.registerTool(
     "inspector_list_models",
     {
@@ -389,6 +414,7 @@ export const TOOL_NAMES = [
   "inspector_get_log",
   "inspector_get_log_chunks",
   "inspector_list_sessions",
+  "inspector_get_session",
   "inspector_list_models",
   "inspector_list_providers",
   "inspector_get_provider",

package/src/mcp/toolHandlers.ts

@@ -17,6 +17,7 @@ import { Buffer } from "node:buffer";
 import { z } from "zod";
 import { LoopbackTimeoutError, type CallApiOptions } from "./loopback";
 import { extractLastUserMessagePreview, extractResponsePreview } from "./previewExtractor";
+import { SessionInfoSchema } from "../lib/sessionInfoContract";
 import { CapturedLogSchema, type CapturedLog } from "../proxy/schemas";
 
 /** Minimal callApi contract: same shape as the real `callApi` in loopback.ts. */
@@ -191,6 +192,32 @@ export async function listSessionsImpl(callApi: CallApiFn): Promise<ToolResult>
   return textJson(await res.json());
 }
 
+export type GetSessionArgs = {
+  sessionId: string;
+  includeHistory?: boolean;
+  latestLogLimit?: number;
+};
+
+export async function getSessionImpl(
+  callApi: CallApiFn,
+  args: GetSessionArgs,
+): Promise<ToolResult> {
+  const params = new URLSearchParams({ sessionId: args.sessionId });
+  if (args.latestLogLimit !== undefined) {
+    params.set("limit", String(args.latestLogLimit));
+  }
+  if (args.includeHistory === true) {
+    params.set("includeHistory", "1");
+  }
+  const path = `/api/sessions?${params.toString()}`;
+  const res = await callApi(path);
+  if (!res.ok) return toolError(`GET ${path} returned ${res.status}`);
+  const rawBody: unknown = await res.json();
+  const parsed = SessionInfoSchema.safeParse(rawBody);
+  if (!parsed.success) return toolError("GET /api/sessions returned an unparseable session info");
+  return textJson(parsed.data);
+}
+
 export async function listModelsImpl(callApi: CallApiFn): Promise<ToolResult> {
   const res = await callApi("/api/models");
   if (!res.ok) return toolError(`GET /api/models returned ${res.status}`);