@tonyclaw/agent-inspector 2.1.15 → 2.1.17

package/src/components/ui/transient-toast.tsx

@@ -0,0 +1,104 @@
+import { AlertTriangle, CheckCircle2, X } from "lucide-react";
+import { useCallback, useEffect, useState, type JSX } from "react";
+
+import { cn } from "../../lib/utils";
+
+export const TRANSIENT_TOAST_AUTO_DISMISS_MS = 3000;
+
+export type TransientToastTone = "error" | "success";
+
+export type TransientToastInput = {
+  message: string;
+  tone?: TransientToastTone;
+};
+
+export type TransientToastNotice = {
+  id: number;
+  message: string;
+  tone: TransientToastTone;
+};
+
+export function createNextTransientToast(
+  previous: TransientToastNotice | null,
+  input: TransientToastInput,
+): TransientToastNotice {
+  return {
+    id: (previous?.id ?? 0) + 1,
+    message: input.message,
+    tone: input.tone ?? "error",
+  };
+}
+
+export function useTransientToast(): {
+  notice: TransientToastNotice | null;
+  showToast: (input: TransientToastInput) => void;
+  dismissToast: () => void;
+} {
+  const [notice, setNotice] = useState<TransientToastNotice | null>(null);
+
+  const showToast = useCallback((input: TransientToastInput) => {
+    setNotice((previous) => createNextTransientToast(previous, input));
+  }, []);
+
+  const dismissToast = useCallback(() => {
+    setNotice(null);
+  }, []);
+
+  useEffect(() => {
+    if (notice === null) return undefined;
+    const timeout = window.setTimeout(() => {
+      setNotice(null);
+    }, TRANSIENT_TOAST_AUTO_DISMISS_MS);
+
+    return () => {
+      window.clearTimeout(timeout);
+    };
+  }, [notice]);
+
+  return { notice, showToast, dismissToast };
+}
+
+export function TransientToast({
+  notice,
+  onDismiss,
+}: {
+  notice: TransientToastNotice | null;
+  onDismiss: () => void;
+}): JSX.Element | null {
+  if (notice === null) return null;
+
+  const isError = notice.tone === "error";
+  const Icon = isError ? AlertTriangle : CheckCircle2;
+
+  return (
+    <div
+      aria-atomic="true"
+      aria-live="polite"
+      className="pointer-events-none fixed top-4 right-4 z-[100] w-[min(calc(100vw-2rem),26rem)]"
+      role="status"
+    >
+      <div
+        key={notice.id}
+        className={cn(
+          "pointer-events-auto flex items-start gap-2 rounded-md border px-3 py-2 text-sm shadow-[0_18px_50px_rgba(0,0,0,0.45)] backdrop-blur",
+          isError
+            ? "border-red-400/30 bg-[#16090b]/95 text-red-100"
+            : "border-cyan-300/25 bg-[#071318]/95 text-cyan-100",
+        )}
+      >
+        <Icon
+          className={cn("mt-0.5 size-4 shrink-0", isError ? "text-red-300" : "text-cyan-200")}
+        />
+        <div className="min-w-0 flex-1 break-words leading-5">{notice.message}</div>
+        <button
+          type="button"
+          className="inline-flex size-6 shrink-0 items-center justify-center rounded-md text-current/70 transition-colors hover:bg-white/10 hover:text-current"
+          aria-label="Dismiss notification"
+          onClick={onDismiss}
+        >
+          <X className="size-3.5" />
+        </button>
+      </div>
+    </div>
+  );
+}

package/src/lib/providerTestContract.ts

@@ -72,22 +72,58 @@ const ProviderFormatTestResultsSchema = z.object({
   streaming: ProviderTestStateSchema,
 });
 
-const ModelTestResultsSchema = z.object({
-  anthropic: ProviderFormatTestResultsSchema,
-  openai: ProviderFormatTestResultsSchema,
-});
+export type ProviderFormatTestResults = z.infer<typeof ProviderFormatTestResultsSchema>;
 
-export const ProviderTestResultsSchema = z.object({
-  anthropic: ProviderFormatTestResultsSchema,
-  openai: ProviderFormatTestResultsSchema,
-  models: z.record(z.string(), ModelTestResultsSchema).optional(),
-  testedAt: z.string().optional(),
-});
+export function createNotConfiguredProviderFormatTestResults(): ProviderFormatTestResults {
+  return {
+    nonStreaming: { notConfigured: true },
+    streaming: { notConfigured: true },
+  };
+}
+
+const ModelTestResultsSchema = z
+  .object({
+    anthropic: ProviderFormatTestResultsSchema,
+    openai: ProviderFormatTestResultsSchema.optional(),
+    openaiChat: ProviderFormatTestResultsSchema.optional(),
+    openaiResponses: ProviderFormatTestResultsSchema.optional(),
+  })
+  .transform((value) => {
+    const openaiChat =
+      value.openaiChat ?? value.openai ?? createNotConfiguredProviderFormatTestResults();
+    return {
+      ...value,
+      openai: value.openai ?? openaiChat,
+      openaiChat,
+      openaiResponses: value.openaiResponses ?? createNotConfiguredProviderFormatTestResults(),
+    };
+  });
+
+export const ProviderTestResultsSchema = z
+  .object({
+    anthropic: ProviderFormatTestResultsSchema,
+    openai: ProviderFormatTestResultsSchema.optional(),
+    openaiChat: ProviderFormatTestResultsSchema.optional(),
+    openaiResponses: ProviderFormatTestResultsSchema.optional(),
+    models: z.record(z.string(), ModelTestResultsSchema).optional(),
+    testedAt: z.string().optional(),
+  })
+  .transform((value) => {
+    const openaiChat =
+      value.openaiChat ?? value.openai ?? createNotConfiguredProviderFormatTestResults();
+    return {
+      ...value,
+      openai: value.openai ?? openaiChat,
+      openaiChat,
+      openaiResponses: value.openaiResponses ?? createNotConfiguredProviderFormatTestResults(),
+    };
+  });
 
 export type ProviderTestErrorType = z.infer<typeof ProviderTestErrorTypeSchema>;
 export type ProviderTestDebug = z.infer<typeof ProviderTestDebugSchema>;
 export type ProviderTestResult = z.infer<typeof ProviderTestResultSchema>;
 export type ProviderTestState = z.infer<typeof ProviderTestStateSchema>;
+export type ProviderModelTestResults = z.infer<typeof ModelTestResultsSchema>;
 export type ProviderTestResults = z.infer<typeof ProviderTestResultsSchema>;
 
 export function createPendingProviderTestResults(): ProviderTestResults {
@@ -100,6 +136,14 @@ export function createPendingProviderTestResults(): ProviderTestResults {
       nonStreaming: { testing: true },
       streaming: { testing: true },
     },
+    openaiChat: {
+      nonStreaming: { testing: true },
+      streaming: { testing: true },
+    },
+    openaiResponses: {
+      nonStreaming: { testing: true },
+      streaming: { testing: true },
+    },
   };
 }
 
@@ -118,5 +162,7 @@ export function createFailedProviderTestResults(
   return {
     anthropic: createFormatResult(),
     openai: createFormatResult(),
+    openaiChat: createFormatResult(),
+    openaiResponses: createFormatResult(),
   };
 }

package/src/lib/providerTestPrompt.ts

@@ -1,17 +1,29 @@
 export type ProviderTestMode = "non-streaming" | "streaming";
+export type ProviderTestApiShape = "chat" | "responses";
 
 export type ProviderTestMessage = {
   role: "user";
   content: string;
 };
 
-export type ProviderTestRequestBody = {
+export type ProviderTestChatRequestBody = {
   model: string;
   messages: ProviderTestMessage[];
   max_tokens: number;
   stream: boolean;
 };
 
+export type ProviderTestResponsesRequestBody = {
+  model: string;
+  input: string;
+  max_output_tokens: number;
+  stream: boolean;
+};
+
+export type ProviderTestRequestBody =
+  | ProviderTestChatRequestBody
+  | ProviderTestResponsesRequestBody;
+
 const MEMORY_PROBE_FACTS = [
   "Project fact: Agent Inspector captures LLM traffic and turns it into Raw Trace, Session Episode, and Memory Candidate layers.",
   "Procedure: before release, run bun test, npm run typecheck, npm run lint, npm run build, and openspec validate --all --strict.",
@@ -63,7 +75,17 @@ export function buildProviderTestMessages(mode: ProviderTestMode): ProviderTestM
 export function buildProviderTestRequestBody(
   model: string,
   mode: ProviderTestMode,
+  apiShape: ProviderTestApiShape = "chat",
 ): ProviderTestRequestBody {
+  if (apiShape === "responses") {
+    return {
+      model,
+      input: buildProviderTestUserPrompt(mode),
+      max_output_tokens: maxTokensForMode(mode),
+      stream: mode === "streaming",
+    };
+  }
+
   const base = {
     model,
     messages: buildProviderTestMessages(mode),

package/src/lib/sessionInfoContract.ts

@@ -32,6 +32,9 @@ export const SessionLogSummarySchema = z.object({
     cacheRead: z.number().nullable(),
   }),
   sessionId: z.string().nullable(),
+  userAgent: z.string().nullable().optional(),
+  clientPid: z.number().nullable().optional(),
+  clientProjectFolder: z.string().nullable().optional(),
 });
 
 export const SessionInfoSchema = z.object({
@@ -56,6 +59,7 @@ export const SessionInfoSchema = z.object({
   tokenUsage: SessionTokenUsageSchema,
   lastLogId: z.number().nullable(),
   lastModel: z.string().nullable(),
+  clientUserAgent: z.string().nullable().optional(),
   clientPid: z.number().nullable(),
   clientProjectFolder: z.string().nullable(),
   inspectorPath: z.string(),

package/src/lib/upstreamUrl.ts

@@ -1,9 +1,24 @@
 export const PATH_V1_CHAT_COMPLETIONS = "/v1/chat/completions";
 export const PATH_V1_RESPONSES = "/v1/responses";
+export const PATH_V1_MESSAGES = "/v1/messages";
+
+export type UpstreamUrlDiagnostic = {
+  severity: "info" | "warning";
+  message: string;
+};
+
+export type UpstreamUrlPreviewOptions = {
+  providerName?: string;
+};
+
+export type UpstreamUrlPreview = {
+  finalUrl: string;
+  diagnostics: UpstreamUrlDiagnostic[];
+};
 
 export function buildUpstreamUrl(upstreamBase: string, normalizedPath: string): string {
   const base = upstreamBase.endsWith("/") ? upstreamBase.slice(0, -1) : upstreamBase;
-  const endpointPath = normalizedPath.split("?")[0] ?? normalizedPath;
+  const endpointPath = endpointPathFor(normalizedPath);
   const queryIndex = normalizedPath.indexOf("?");
   const search = queryIndex >= 0 ? normalizedPath.slice(queryIndex) : "";
 
@@ -24,6 +39,62 @@ export function buildUpstreamUrl(upstreamBase: string, normalizedPath: string):
   return base + normalizedPath;
 }
 
+export function previewUpstreamUrl(
+  upstreamBase: string,
+  normalizedPath: string,
+  options: UpstreamUrlPreviewOptions = {},
+): UpstreamUrlPreview {
+  const base = upstreamBase.trim().replace(/\/+$/, "");
+  const endpointPath = endpointPathFor(normalizedPath);
+  const finalUrl = buildUpstreamUrl(base, normalizedPath);
+  const diagnostics: UpstreamUrlDiagnostic[] = [];
+  const exactEndpoint = endpointPath !== "" && base.endsWith(endpointPath);
+
+  if (exactEndpoint) {
+    diagnostics.push({
+      severity: "info",
+      message: "This already includes the exact endpoint; no duplicate suffix will be appended.",
+    });
+  } else if (isZhipuVersionedOpenAIBase(base) && isVersionedChatCompletionsPath(normalizedPath)) {
+    diagnostics.push({
+      severity: "info",
+      message: "Zhipu bases already include the API version; only /chat/completions is appended.",
+    });
+  } else if (base.endsWith("/v1") && normalizedPath.startsWith("/v1/")) {
+    diagnostics.push({
+      severity: "info",
+      message: "Base URL already ends with /v1; the suffix will not repeat /v1.",
+    });
+  }
+
+  if (isResponsesPath(endpointPath) && baseEndsWithChatEndpoint(base)) {
+    diagnostics.push({
+      severity: "warning",
+      message: "This looks like a Chat Completions endpoint, so Responses would append after it.",
+    });
+  }
+
+  if (isChatCompletionsPath(endpointPath) && baseEndsWithResponsesEndpoint(base)) {
+    diagnostics.push({
+      severity: "warning",
+      message: "This looks like a Responses endpoint, so Chat Completions would append after it.",
+    });
+  }
+
+  if (isResponsesPath(endpointPath) && isLikelyDeepSeekBase(base, options.providerName)) {
+    diagnostics.push({
+      severity: "warning",
+      message: "DeepSeek's official API does not currently expose OpenAI Responses.",
+    });
+  }
+
+  return { finalUrl, diagnostics };
+}
+
+function endpointPathFor(normalizedPath: string): string {
+  return normalizedPath.split("?")[0] ?? normalizedPath;
+}
+
 function isVersionedChatCompletionsPath(normalizedPath: string): boolean {
   return (
     normalizedPath === PATH_V1_CHAT_COMPLETIONS ||
@@ -32,6 +103,39 @@ function isVersionedChatCompletionsPath(normalizedPath: string): boolean {
   );
 }
 
+function isChatCompletionsPath(endpointPath: string): boolean {
+  return (
+    endpointPath === PATH_V1_CHAT_COMPLETIONS ||
+    endpointPath.startsWith(`${PATH_V1_CHAT_COMPLETIONS}/`)
+  );
+}
+
+function isResponsesPath(endpointPath: string): boolean {
+  return endpointPath === PATH_V1_RESPONSES || endpointPath.startsWith(`${PATH_V1_RESPONSES}/`);
+}
+
+function baseEndsWithChatEndpoint(base: string): boolean {
+  const normalized = base.toLowerCase();
+  return normalized.endsWith("/chat/completions");
+}
+
+function baseEndsWithResponsesEndpoint(base: string): boolean {
+  const normalized = base.toLowerCase();
+  return normalized.endsWith("/responses");
+}
+
+function isLikelyDeepSeekBase(base: string, providerName: string | undefined): boolean {
+  const provider = providerName?.toLowerCase();
+  if (provider !== undefined && provider.includes("deepseek")) return true;
+
+  try {
+    const parsed = new URL(base);
+    return parsed.hostname.toLowerCase().includes("deepseek");
+  } catch {
+    return base.toLowerCase().includes("deepseek");
+  }
+}
+
 function isZhipuVersionedOpenAIBase(base: string): boolean {
   try {
     const parsed = new URL(base);

package/src/mcp/server.ts

@@ -185,7 +185,7 @@ Parameters:
 Returns: array of "thick summary" objects, each containing:
   - id, timestamp, provider, model, apiFormat, method, path, status, isStreaming,
     hasError, latencyMs, tokens { input, output, cacheCreate, cacheRead },
-    sessionId, clientPid,
+    sessionId, userAgent, clientPid, clientCwd, clientProjectFolder,
   - lastUserMessagePreview (string|null, ≤500 chars) — first text block of the last user message, parsed via the format-specific schema (NOT a raw body slice)
   - responsePreview (string|null, ≤500 chars) — first text block of the assistant response
   - hasChunks, hasRawRequestBody (booleans)
@@ -195,6 +195,72 @@ Either preview field is null when the body is unknown format, unparseable, or th
 const PROVIDER_WRITE_WARNING =
   "⚠ This tool mutates provider configuration. Confirm with the user before invoking.";
 
+const AddProviderInputSchema = z
+  .object({
+    name: z.string().min(1).describe("Provider display name."),
+    apiKey: z.string().min(1).describe("Plaintext provider API key."),
+    format: z
+      .enum(["anthropic", "openai"])
+      .optional()
+      .describe("Primary API family. Use openai for Chat Completions or Responses providers."),
+    model: z
+      .string()
+      .min(1)
+      .optional()
+      .describe("Legacy single-model input. Prefer models for new clients."),
+    models: z.array(z.string().min(1)).min(1).optional().describe("Provider model names."),
+    anthropicBaseUrl: z
+      .string()
+      .optional()
+      .describe("Anthropic-compatible base or exact /v1/messages endpoint."),
+    openaiBaseUrl: z
+      .string()
+      .optional()
+      .describe("OpenAI Chat Completions base or exact /v1/chat/completions endpoint."),
+    openaiResponsesBaseUrl: z
+      .string()
+      .optional()
+      .describe(
+        "OpenAI Responses base or exact /v1/responses endpoint. MiniMax default endpoint is https://api.minimaxi.com/v1/responses.",
+      ),
+    authHeader: z.enum(["bearer", "x-api-key"]).optional(),
+    apiDocsUrl: z.string().optional(),
+  })
+  .refine(
+    (input) => input.model !== undefined || (input.models !== undefined && input.models.length > 0),
+    { message: "Provide models or legacy model." },
+  );
+
+const UpdateProviderInputSchema = z.object({
+  id: z.string().describe("The provider id to update."),
+  name: z.string().min(1).optional(),
+  apiKey: z.string().min(1).optional(),
+  format: z.enum(["anthropic", "openai"]).optional(),
+  model: z.string().min(1).optional().describe("Legacy single-model input. Prefer models."),
+  models: z.array(z.string().min(1)).optional().describe("Replace provider model names."),
+  baseUrl: z
+    .string()
+    .min(1)
+    .optional()
+    .describe("Legacy route URL retained for old configs; prefer format-specific URL fields."),
+  authHeader: z.enum(["bearer", "x-api-key"]).optional(),
+  anthropicBaseUrl: z
+    .string()
+    .optional()
+    .describe("Anthropic-compatible base or exact /v1/messages endpoint."),
+  openaiBaseUrl: z
+    .string()
+    .optional()
+    .describe("OpenAI Chat Completions base or exact /v1/chat/completions endpoint."),
+  openaiResponsesBaseUrl: z
+    .string()
+    .optional()
+    .describe(
+      "OpenAI Responses base or exact /v1/responses endpoint. MiniMax default endpoint is https://api.minimaxi.com/v1/responses.",
+    ),
+  apiDocsUrl: z.string().optional(),
+});
+
 const LogResourceListResponseSchema = z.object({
   logs: z.array(z.object({ id: z.number().int().positive() })),
 });
@@ -1049,18 +1115,8 @@ function registerTools(server: McpServer): void {
     "inspector_add_provider",
     {
       title: "Add a new LLM provider",
-      description: `${PROVIDER_WRITE_WARNING}\n\nPersists a new provider to <dataDir>/providers.json. Required fields: name, apiKey, format (anthropic|openai), model. Optional: baseUrl, authHeader (default: bearer), apiDocsUrl.`,
-      inputSchema: z.object({
-        name: z.string().min(1),
-        apiKey: z.string().min(1),
-        format: z.enum(["anthropic", "openai"]),
-        model: z.string().min(1),
-        anthropicBaseUrl: z.string().optional(),
-        openaiBaseUrl: z.string().optional(),
-        openaiResponsesBaseUrl: z.string().optional(),
-        authHeader: z.enum(["bearer", "x-api-key"]).optional(),
-        apiDocsUrl: z.string().optional(),
-      }),
+      description: `${PROVIDER_WRITE_WARNING}\n\nPersists a new provider to <dataDir>/providers.json. Required fields: name, apiKey, and models (or legacy model). Chat Completions and Responses can use different upstream URLs: set openaiBaseUrl for /v1/chat/completions and openaiResponsesBaseUrl for /v1/responses. The URL builder accepts either a base URL such as https://api.minimaxi.com or an exact endpoint such as https://api.minimaxi.com/v1/responses.`,
+      inputSchema: AddProviderInputSchema,
     },
     (provider) => safeWriteCall("inspector_add_provider", () => addProviderImpl(callApi, provider)),
   );
@@ -1071,20 +1127,8 @@ function registerTools(server: McpServer): void {
       title: "Update an existing provider",
       description: `${PROVIDER_WRITE_WARNING} Updating with nonsense values effectively soft-deletes a provider. Confirm with the user before invoking.
 
-PATCH-style update: only the fields you supply are changed. Returns the updated ProviderConfig.`,
-      inputSchema: z.object({
-        id: z.string().describe("The provider id to update."),
-        name: z.string().min(1).optional(),
-        apiKey: z.string().min(1).optional(),
-        format: z.enum(["anthropic", "openai"]).optional(),
-        model: z.string().min(1).optional(),
-        baseUrl: z.string().min(1).optional(),
-        authHeader: z.enum(["bearer", "x-api-key"]).optional(),
-        anthropicBaseUrl: z.string().optional(),
-        openaiBaseUrl: z.string().optional(),
-        openaiResponsesBaseUrl: z.string().optional(),
-        apiDocsUrl: z.string().optional(),
-      }),
+PATCH-style update: only the fields you supply are changed. Use models to update the configured model list. For OpenAI-compatible providers, openaiBaseUrl targets /v1/chat/completions and openaiResponsesBaseUrl targets /v1/responses, and those endpoints may be different.`,
+      inputSchema: UpdateProviderInputSchema,
     },
     (input) => safeWriteCall("inspector_update_provider", () => updateProviderImpl(callApi, input)),
   );

package/src/mcp/toolHandlers.ts

@@ -175,7 +175,10 @@ export function buildLogSummary(log: CapturedLog) {
       cacheRead: log.cacheReadInputTokens,
     },
     sessionId: log.sessionId,
+    userAgent: log.userAgent ?? null,
     clientPid: log.clientPid ?? null,
+    clientCwd: log.clientCwd ?? null,
+    clientProjectFolder: log.clientProjectFolder ?? null,
     lastUserMessagePreview: extractLastUserMessagePreview(log),
     responsePreview: extractResponsePreview(log),
     hasChunks:
@@ -715,8 +718,9 @@ export async function replayLogImpl(callApi: CallApiFn, args: ReplayLogArgs): Pr
 export type AddProviderInput = {
   name: string;
   apiKey: string;
-  format: "anthropic" | "openai";
-  model: string;
+  format?: "anthropic" | "openai";
+  model?: string;
+  models?: string[];
   anthropicBaseUrl?: string;
   openaiBaseUrl?: string;
   openaiResponsesBaseUrl?: string;
@@ -724,14 +728,23 @@ export type AddProviderInput = {
   apiDocsUrl?: string;
 };
 
+function normalizedProviderModels(input: { model?: string; models?: readonly string[] }): string[] {
+  const modelList = input.models ?? [];
+  const models = modelList.map((model) => model.trim()).filter((model) => model !== "");
+  if (models.length > 0) return models;
+  const model = input.model?.trim();
+  return model !== undefined && model !== "" ? [model] : [];
+}
+
 export async function addProviderImpl(
   callApi: CallApiFn,
   provider: AddProviderInput,
 ): Promise<ToolResult> {
+  const models = normalizedProviderModels(provider);
   const res = await callApi("/api/providers", {
     method: "POST",
     headers: { "content-type": "application/json" },
-    body: JSON.stringify(provider),
+    body: JSON.stringify({ ...provider, models }),
   });
   if (!res.ok) return toolError(`POST /api/providers returned ${res.status}`);
   return textJson(await res.json());
@@ -743,6 +756,7 @@ export type UpdateProviderInput = {
   apiKey?: string;
   format?: "anthropic" | "openai";
   model?: string;
+  models?: string[];
   baseUrl?: string;
   authHeader?: "bearer" | "x-api-key";
   anthropicBaseUrl?: string;
@@ -756,10 +770,15 @@ export async function updateProviderImpl(
   input: UpdateProviderInput,
 ): Promise<ToolResult> {
   const { id, ...patch } = input;
+  const models =
+    patch.models !== undefined || patch.model !== undefined
+      ? normalizedProviderModels(patch)
+      : undefined;
+  const body = models === undefined ? patch : { ...patch, models };
   const res = await callApi(`/api/providers/${encodeURIComponent(id)}`, {
     method: "PUT",
     headers: { "content-type": "application/json" },
-    body: JSON.stringify(patch),
+    body: JSON.stringify(body),
   });
   if (!res.ok) return toolError(`PUT /api/providers/${id} returned ${res.status}`);
   return textJson(await res.json());
@@ -888,7 +907,7 @@ function providerDiagnosticHints(result: unknown): string[] {
   }
   if (text.includes("nonstream") || text.includes("non-stream")) {
     hints.push(
-      "The failure mentions non-streaming. Compare the OpenAI/Anthropic non-streaming path and payload with the streaming request.",
+      "The failure mentions non-streaming. Compare the Anthropic, OpenAI Chat, and OpenAI Responses non-streaming path and payload with the streaming request.",
     );
   }
   return [...new Set(hints)];

package/src/proxy/formats/openai/alibabaProvider.ts

@@ -14,10 +14,6 @@ export const alibabaProvider: ProviderAdapter = {
   matches(model: string): boolean {
     // Normalize: lowercase, replace whitespace with hyphens
     const m = model.toLowerCase().replace(/\s+/g, "-");
-    // Match glm-5* and glm-5.1* models
-    if (m.startsWith("glm-5")) {
-      return true;
-    }
     // Match qwen models (qwen3.6-plus, qwen3.7-max, Qwen3.6 Plus, etc.)
     if (m.startsWith("qwen")) {
       return true;

package/src/proxy/sessionInfo.ts

@@ -65,6 +65,9 @@ export function buildSessionLogSummary(log: CapturedLog): SessionLogSummary {
       cacheRead: log.cacheReadInputTokens,
     },
     sessionId: normalizeString(log.sessionId),
+    userAgent: normalizeString(log.userAgent),
+    clientPid: log.clientPid ?? null,
+    clientProjectFolder: normalizeString(log.clientProjectFolder),
   };
 }
 
@@ -118,6 +121,30 @@ function collectSortedValues(values: readonly (string | null)[]): string[] {
   return [...set].sort();
 }
 
+function firstSummaryUserAgent(summaries: readonly SessionLogSummary[]): string | null {
+  for (const summary of summaries) {
+    const value = normalizeString(summary.userAgent);
+    if (value !== null) return value;
+  }
+  return null;
+}
+
+function firstSummaryClientPid(summaries: readonly SessionLogSummary[]): number | null {
+  for (const summary of summaries) {
+    const value = summary.clientPid;
+    if (value !== null && value !== undefined) return value;
+  }
+  return null;
+}
+
+function firstSummaryProjectFolder(summaries: readonly SessionLogSummary[]): string | null {
+  for (const summary of summaries) {
+    const value = normalizeString(summary.clientProjectFolder);
+    if (value !== null) return value;
+  }
+  return null;
+}
+
 function countCompletedLogs(summaries: readonly SessionLogSummary[]): number {
   let count = 0;
   for (const summary of summaries) {
@@ -215,8 +242,10 @@ export function buildSessionInfo(input: BuildSessionInfoInput): SessionInfo {
     tokenUsage,
     lastLogId: input.snapshot?.lastLogId ?? latestLog?.id ?? null,
     lastModel: normalizeString(input.snapshot?.lastModel) ?? latestLog?.model ?? null,
-    clientPid: input.snapshot?.clientPid ?? null,
-    clientProjectFolder: normalizeString(input.snapshot?.clientProjectFolder),
+    clientUserAgent: firstSummaryUserAgent(summaries),
+    clientPid: input.snapshot?.clientPid ?? firstSummaryClientPid(summaries),
+    clientProjectFolder:
+      normalizeString(input.snapshot?.clientProjectFolder) ?? firstSummaryProjectFolder(summaries),
     inspectorPath,
     inspectorUrl: buildAbsoluteUrl(input.baseUrl, inspectorPath),
     apiPath,