@tonyclaw/agent-inspector 2.0.0 → 2.0.2

package/src/cli/onboard.ts

@@ -1,12 +1,13 @@
 /**
  * `agent-inspector onboard` subcommand.
  *
- * Generates a Claude Code skill + slash command into the user's home dir so
- * the user can run `/agent-inspector:onboard` to walk through a guided setup.
+ * Generates Agent Inspector onboarding skills into the user's home dir.
+ * Claude Code gets a skill + slash command. Codex gets a skill under
+ * ~/.codex/skills that guides the user through connecting /api/mcp.
  *
- * Idempotent by default: re-runs without `--force` are no-ops. `--force`
- * overwrites, `--dry-run` writes nothing. Designed as an explicit setup step
- * that can fail softly without blocking normal CLI use.
+ * Idempotent by default: re-runs without `--force` only write missing files.
+ * `--force` overwrites, `--dry-run` writes nothing. Designed as an explicit
+ * setup step that can fail softly without blocking normal CLI use.
  */
 
 import { mkdirSync, writeFileSync, existsSync, readFileSync } from "node:fs";
@@ -16,6 +17,10 @@ import { fileURLToPath } from "node:url";
 
 import { detectAll, detectFirst } from "./detect-tools.js";
 import { renderCommandOnboard } from "./templates/command-onboard.js";
+import {
+  renderCodexSkillOnboard,
+  REQUIRED_CODEX_PHASE_HEADINGS,
+} from "./templates/codex-skill-onboard.js";
 import { renderSkillOnboard, REQUIRED_PHASE_HEADINGS } from "./templates/skill-onboard.js";
 
 const __filename = fileURLToPath(import.meta.url);
@@ -37,7 +42,23 @@ export type OnboardFlags = {
   dryRun: boolean;
   skipProvider: boolean;
   skipToolWire: boolean;
+  codexOnly: boolean;
+  skipCodexSkill: boolean;
   skillDir: string | null;
+  codexSkillDir: string | null;
+};
+
+type OnboardTargets = {
+  claudeSkillFile: string;
+  claudeCommandFile: string;
+  codexSkillFile: string;
+};
+
+type PlannedFile = {
+  label: string;
+  path: string;
+  body: string;
+  enabled: boolean;
 };
 
 function parseFlags(argv: readonly string[]): OnboardFlags {
@@ -46,7 +67,10 @@ function parseFlags(argv: readonly string[]): OnboardFlags {
     dryRun: false,
     skipProvider: false,
     skipToolWire: false,
+    codexOnly: false,
+    skipCodexSkill: false,
     skillDir: null,
+    codexSkillDir: null,
   };
   for (let i = 0; i < argv.length; i++) {
     const arg = argv[i];
@@ -65,6 +89,12 @@ function parseFlags(argv: readonly string[]): OnboardFlags {
       case "--skip-tool-wire":
         flags.skipToolWire = true;
         break;
+      case "--codex-only":
+        flags.codexOnly = true;
+        break;
+      case "--skip-codex-skill":
+        flags.skipCodexSkill = true;
+        break;
       case "--skill-dir": {
         const next = argv[i + 1];
         if (next === undefined) {
@@ -75,6 +105,18 @@ function parseFlags(argv: readonly string[]): OnboardFlags {
         i++;
         break;
       }
+      case "--codex-skill-dir": {
+        const next = argv[i + 1];
+        if (next === undefined) {
+          process.stderr.write(
+            "agent-inspector onboard: --codex-skill-dir requires a path argument\n",
+          );
+          process.exit(2);
+        }
+        flags.codexSkillDir = next;
+        i++;
+        break;
+      }
       case "--help":
       case "-h":
         printHelp();
@@ -89,18 +131,21 @@ function parseFlags(argv: readonly string[]): OnboardFlags {
 }
 
 function printHelp(): void {
-  process.stdout.write(`agent-inspector onboard — install the agent-inspector Claude Code skill
+  process.stdout.write(`agent-inspector onboard - install Agent Inspector onboarding skills
 
 Usage:
   agent-inspector onboard [options]
 
 Options:
-  --force              Overwrite the existing skill and slash command if they exist
-  --dry-run            Print target paths and a template preview, write nothing
-  --skip-provider      Skip the provider-setup phase in the skill body
-  --skip-tool-wire     Skip the wire-tool phase in the skill body
-  --skill-dir <path>   Override the target skill directory (default: ~/.claude/skills)
-  -h, --help           Show this help
+  --force                  Overwrite existing generated skills and slash command
+  --dry-run                Print target paths and template previews, write nothing
+  --skip-provider          Skip the provider-setup phase in the Claude skill body
+  --skip-tool-wire         Skip the wire-tool phase in the Claude skill body
+  --skip-codex-skill       Install only the Claude Code skill and slash command
+  --codex-only             Install only the Codex skill
+  --skill-dir <path>       Override the target Claude root directory (default: ~/.claude)
+  --codex-skill-dir <path> Override the target Codex skills directory (default: ~/.codex/skills)
+  -h, --help               Show this help
 
 Exit codes:
   0  success (or already installed)
@@ -109,16 +154,16 @@ Exit codes:
 `);
 }
 
-function resolveTargets(flags: OnboardFlags): {
-  skillFile: string;
-  commandFile: string;
-} {
+function resolveTargets(flags: OnboardFlags): OnboardTargets {
   const claudeRoot = flags.skillDir ?? join(homedir(), ".claude");
-  const skillDir = join(claudeRoot, "skills", SKILL_DIR_NAME);
-  const commandsDir = join(claudeRoot, "commands");
+  const claudeSkillDir = join(claudeRoot, "skills", SKILL_DIR_NAME);
+  const claudeCommandsDir = join(claudeRoot, "commands");
+  const codexRoot = process.env["CODEX_HOME"] ?? join(homedir(), ".codex");
+  const codexSkillsDir = flags.codexSkillDir ?? join(codexRoot, "skills");
   return {
-    skillFile: join(skillDir, SKILL_FILE_NAME),
-    commandFile: join(commandsDir, COMMAND_FILE_NAME),
+    claudeSkillFile: join(claudeSkillDir, SKILL_FILE_NAME),
+    claudeCommandFile: join(claudeCommandsDir, COMMAND_FILE_NAME),
+    codexSkillFile: join(codexSkillsDir, SKILL_DIR_NAME, SKILL_FILE_NAME),
   };
 }
 
@@ -135,6 +180,67 @@ function buildDetectedSummary(): string {
   return `  - Detected: ${presentList}\n  - Not detected: ${absentList}`;
 }
 
+function readPackageVersion(): string {
+  try {
+    const raw: unknown = JSON.parse(readFileSync(join(__dirname, "..", "package.json"), "utf8"));
+    if (isObject(raw) && typeof raw["version"] === "string") {
+      return raw["version"];
+    }
+  } catch {
+    // best-effort: leave version as the fallback
+  }
+  return "0.0.0";
+}
+
+function buildPlannedFiles(
+  flags: OnboardFlags,
+  targets: OnboardTargets,
+  version: string,
+): PlannedFile[] {
+  const installClaude = !flags.codexOnly;
+  const installCodex = !flags.skipCodexSkill;
+  const detectedSummary = installClaude ? buildDetectedSummary() : "";
+  const claudeSkillBody = installClaude
+    ? renderSkillOnboard({
+        version,
+        port: DEFAULT_PORT,
+        detectedSummary,
+      })
+    : "";
+  const commandBody = installClaude ? renderCommandOnboard() : "";
+  const codexSkillBody = installCodex
+    ? renderCodexSkillOnboard({
+        version,
+        port: DEFAULT_PORT,
+      })
+    : "";
+
+  return [
+    {
+      label: "Claude skill",
+      path: targets.claudeSkillFile,
+      body: claudeSkillBody,
+      enabled: installClaude,
+    },
+    {
+      label: "Claude command",
+      path: targets.claudeCommandFile,
+      body: commandBody,
+      enabled: installClaude,
+    },
+    {
+      label: "Codex skill",
+      path: targets.codexSkillFile,
+      body: codexSkillBody,
+      enabled: installCodex,
+    },
+  ];
+}
+
+function shouldWrite(file: PlannedFile, force: boolean): boolean {
+  return file.enabled && (force || !existsSync(file.path));
+}
+
 export function runOnboard(argv: readonly string[]): Promise<number> {
   try {
     return Promise.resolve(runOnboardSync(argv));
@@ -149,62 +255,57 @@ export function runOnboard(argv: readonly string[]): Promise<number> {
 
 function runOnboardSync(argv: readonly string[]): number {
   const flags = parseFlags(argv);
-  const { skillFile, commandFile } = resolveTargets(flags);
-
-  // Idempotency check — only relevant for the skill file. If the slash
-  // command file is missing but the skill is present, that's weird; treat
-  // it the same as "already installed" so a partial state doesn't get
-  // half-rewritten on the next run.
-  if (!flags.force && existsSync(skillFile)) {
-    process.stdout.write(`agent-inspector onboard: already installed at ${skillFile}\n`);
-    process.stdout.write("Re-run with --force to refresh.\n");
-    return 0;
-  }
+  const targets = resolveTargets(flags);
+  const version = readPackageVersion();
+  const plannedFiles = buildPlannedFiles(flags, targets, version);
+  const enabledFiles = plannedFiles.filter((file) => file.enabled);
 
-  // Version stamp — read from package.json so the skill and the published
-  // package can never disagree about which version wrote them.
-  let version = "0.0.0";
-  try {
-    const raw: unknown = JSON.parse(readFileSync(join(__dirname, "..", "package.json"), "utf8"));
-    if (isObject(raw) && typeof raw["version"] === "string") {
-      version = raw["version"];
-    }
-  } catch {
-    // best-effort: leave version as the fallback
+  if (enabledFiles.length === 0) {
+    process.stderr.write("agent-inspector onboard: no onboarding target selected\n");
+    return 2;
   }
 
-  const detectedSummary = buildDetectedSummary();
-  const skillBody = renderSkillOnboard({
-    version,
-    port: DEFAULT_PORT,
-    detectedSummary,
-  });
-  const commandBody = renderCommandOnboard();
-
   if (flags.dryRun) {
     process.stdout.write(`agent-inspector onboard --dry-run\n\n`);
-    process.stdout.write(`Skill target:     ${skillFile}\n`);
-    process.stdout.write(`Command target:   ${commandFile}\n\n`);
-    process.stdout.write(`Skill preview (first 5 lines + headings):\n`);
-    const previewLines = skillBody.split("\n").slice(0, 5);
-    process.stdout.write(`${previewLines.join("\n")}\n`);
-    process.stdout.write(`...\n`);
-    for (const heading of REQUIRED_PHASE_HEADINGS) {
-      process.stdout.write(`  - ${heading}\n`);
+    for (const file of enabledFiles) {
+      const status = existsSync(file.path) ? "exists" : "missing";
+      process.stdout.write(`${file.label}: ${file.path} (${status})\n`);
+    }
+    process.stdout.write(`\nClaude skill headings:\n`);
+    if (!flags.codexOnly) {
+      for (const heading of REQUIRED_PHASE_HEADINGS) {
+        process.stdout.write(`  - ${heading}\n`);
+      }
+    } else {
+      process.stdout.write(`  (disabled by --codex-only)\n`);
+    }
+    process.stdout.write(`\nCodex skill headings:\n`);
+    if (!flags.skipCodexSkill) {
+      for (const heading of REQUIRED_CODEX_PHASE_HEADINGS) {
+        process.stdout.write(`  - ${heading}\n`);
+      }
+    } else {
+      process.stdout.write(`  (disabled by --skip-codex-skill)\n`);
+    }
+    if (!flags.codexOnly) {
+      process.stdout.write(`\nDetected tools:\n${buildDetectedSummary()}\n`);
     }
-    process.stdout.write(`\nDetected tools:\n${detectedSummary}\n`);
     process.stdout.write(`\nNo files were written.\n`);
     return 0;
   }
 
-  // Ensure target dirs exist. mkdirSync with recursive: true is a no-op if
-  // the dir already exists; failures are caught by the outer try/catch.
-  mkdirSync(join(skillFile, ".."), { recursive: true });
-  mkdirSync(join(commandFile, ".."), { recursive: true });
+  const filesToWrite = plannedFiles.filter((file) => shouldWrite(file, flags.force));
+  if (filesToWrite.length === 0) {
+    process.stdout.write("agent-inspector onboard: all selected onboarding files already exist\n");
+    process.stdout.write("Re-run with --force to refresh.\n");
+    return 0;
+  }
 
   try {
-    writeFileSync(skillFile, skillBody, "utf8");
-    writeFileSync(commandFile, commandBody, "utf8");
+    for (const file of filesToWrite) {
+      mkdirSync(dirname(file.path), { recursive: true });
+      writeFileSync(file.path, file.body, "utf8");
+    }
   } catch (err) {
     const msg = err instanceof Error ? err.message : String(err);
     process.stderr.write(`agent-inspector onboard: failed to write files: ${msg}\n`);
@@ -214,11 +315,17 @@ function runOnboardSync(argv: readonly string[]): number {
   const firstTool = detectFirst();
   const toolHint = firstTool !== null ? firstTool.displayName : "no known tool detected";
 
-  process.stdout.write(`Installed skill to:   ${skillFile}\n`);
-  process.stdout.write(`Installed command to: ${commandFile}\n`);
+  for (const file of filesToWrite) {
+    process.stdout.write(`Installed ${file.label} to: ${file.path}\n`);
+  }
   process.stdout.write(`\nNext steps:\n`);
-  process.stdout.write(`  - Open Claude Code and run: /agent-inspector:onboard\n`);
-  process.stdout.write(`  - Or refresh later: agent-inspector onboard --force\n`);
+  if (!flags.codexOnly) {
+    process.stdout.write(`  - Open Claude Code and run: /agent-inspector:onboard\n`);
+  }
+  if (!flags.skipCodexSkill) {
+    process.stdout.write(`  - Open Codex and ask to use the agent-inspector-onboard skill\n`);
+  }
+  process.stdout.write(`  - Refresh later: agent-inspector onboard --force\n`);
   process.stdout.write(`  - Detected primary tool: ${toolHint}\n`);
   return 0;
 }

package/src/cli/templates/codex-skill-onboard.ts

@@ -0,0 +1,210 @@
+/**
+ * Renders `~/.codex/skills/agent-inspector-onboard/SKILL.md` for Codex.
+ *
+ * This is intentionally separate from the Claude Code onboarding skill because
+ * Codex uses `~/.codex/config.toml` and supports streamable HTTP MCP servers via
+ * `mcp_servers.<id>.url`.
+ */
+
+export type CodexSkillOnboardContext = {
+  /** Package version (from `package.json`), stamped into the frontmatter. */
+  readonly version: string;
+  /** The default proxy port (mirrors `DEFAULT_PORT` in `src/cli.ts`). */
+  readonly port: number;
+};
+
+export const REQUIRED_CODEX_PHASE_HEADINGS = [
+  "Phase 0: Preflight",
+  "Phase 1: Start Agent Inspector",
+  "Phase 2: Wire Codex MCP",
+  "Phase 3: Restart and verify Codex",
+  "Phase 4: First Inspector query",
+  "Phase 5: Capture and memory review",
+] as const;
+
+export function renderCodexSkillOnboard(ctx: CodexSkillOnboardContext): string {
+  const { version, port } = ctx;
+  return `---
+name: agent-inspector-onboard
+description: Guide Codex users through connecting Agent Inspector v${version} as a local MCP server.
+metadata:
+  author: agent-inspector
+  version: ${version}
+---
+
+# Agent Inspector onboard for Codex
+
+Use this skill when the user wants to set up Agent Inspector inside Codex, connect the Agent Inspector MCP server, inspect captured model traffic from Codex, or turn Inspector sessions into reviewable knowledge candidates.
+
+Agent Inspector runs a local web UI, proxy, REST API, and MCP endpoint on the same port. The default MCP endpoint is:
+
+\`\`\`text
+http://localhost:${port}/api/mcp
+\`\`\`
+
+This skill is installed at \`~/.codex/skills/agent-inspector-onboard/SKILL.md\`.
+Codex user-level configuration lives in \`~/.codex/config.toml\`. Codex supports streamable HTTP MCP servers with \`mcp_servers.<id>.url\`, so no extra stdio bridge package is needed.
+
+Keep this setup local and explicit. Agent Inspector MCP tools can read captured requests and provider configuration, so only wire it into trusted local Codex environments.
+
+---
+
+## Phase 0: Preflight
+
+Check that the package and Codex home exist without printing secrets.
+
+\`\`\`powershell
+Get-Command agent-inspector -ErrorAction SilentlyContinue | Select-Object -ExpandProperty Source
+Test-Path (Join-Path $env:USERPROFILE ".codex")
+Test-Path (Join-Path $env:USERPROFILE ".codex\\config.toml")
+\`\`\`
+
+\`\`\`bash
+command -v agent-inspector || true
+test -d "$HOME/.codex" && echo "codex home: present" || echo "codex home: missing"
+test -f "$HOME/.codex/config.toml" && echo "config: present" || echo "config: missing"
+\`\`\`
+
+If \`agent-inspector\` is missing, ask the user to install it first:
+
+\`\`\`bash
+npm install -g @tonyclaw/agent-inspector
+\`\`\`
+
+Do not read \`~/.codex/auth.json\`, token files, or unrelated Codex state files.
+
+---
+
+## Phase 1: Start Agent Inspector
+
+Start or reuse Agent Inspector before wiring MCP. Prefer the installed binary so Windows users get the branded runtime in Task Manager.
+
+\`\`\`powershell
+agent-inspector --background --no-open
+Invoke-RestMethod -Uri "http://localhost:${port}/api/health" -TimeoutSec 3
+\`\`\`
+
+\`\`\`bash
+agent-inspector --background --no-open
+curl -fsS "http://localhost:${port}/api/health"
+\`\`\`
+
+If the health check fails, show only the relevant error and ask whether to diagnose startup before editing Codex config.
+
+---
+
+## Phase 2: Wire Codex MCP
+
+Add an \`agent-inspector\` MCP server to \`~/.codex/config.toml\`. Preserve the user's existing config and merge the table instead of replacing the file.
+
+Recommended user-level config:
+
+\`\`\`toml
+[mcp_servers.agent-inspector]
+url = "http://localhost:${port}/api/mcp"
+startup_timeout_sec = 30
+tool_timeout_sec = 60
+\`\`\`
+
+If the user's Codex environment is managed by an admin allowlist, they may also need a matching identity rule in the managed requirements layer:
+
+\`\`\`toml
+[mcp_servers.agent-inspector.identity]
+url = "http://localhost:${port}/api/mcp"
+\`\`\`
+
+When editing:
+
+- Ask before changing \`~/.codex/config.toml\`.
+- Keep existing \`mcp_servers.*\`, \`projects.*\`, profiles, sandbox, approval, and model settings intact.
+- Do not write provider API keys into Codex config.
+- Do not expose Agent Inspector MCP beyond localhost.
+
+---
+
+## Phase 3: Restart and verify Codex
+
+Tell the user that Codex loads MCP servers at session startup. After saving \`config.toml\`, they should start a new Codex session or restart the Codex app.
+
+Before restart, verify the HTTP endpoint itself:
+
+\`\`\`bash
+curl -sS -X POST "http://localhost:${port}/api/mcp" \\
+  -H "Content-Type: application/json" \\
+  -H "Accept: application/json, text/event-stream" \\
+  -d '{
+    "jsonrpc": "2.0",
+    "id": 1,
+    "method": "initialize",
+    "params": {
+      "protocolVersion": "2025-03-26",
+      "capabilities": {},
+      "clientInfo": { "name": "codex-onboard-check", "version": "0" }
+    }
+  }'
+\`\`\`
+
+Expected signal: a 200 response containing \`serverInfo\` with \`agent-inspector\`.
+
+---
+
+## Phase 4: First Inspector query
+
+After Codex restarts with the MCP server configured, ask Codex to use Agent Inspector:
+
+\`\`\`text
+Use Agent Inspector to list the latest captured logs.
+\`\`\`
+
+The expected tool is \`inspector_list_logs\`. If no logs exist yet, that is still a successful MCP connection.
+
+Useful follow-up tools:
+
+- \`inspector_list_logs\`
+- \`inspector_get_log\`
+- \`inspector_get_log_chunks\`
+- \`inspector_list_sessions\`
+- \`inspector_test_provider\`
+- \`inspector_create_session_knowledge\`
+- \`inspector_list_knowledge_candidates\`
+- \`inspector_search_knowledge\`
+- \`inspector_get_project_context\`
+
+Provider mutation tools expose and modify local provider configuration. Ask for explicit user confirmation before using \`inspector_add_provider\`, \`inspector_update_provider\`, or \`inspector_replay_log\`.
+
+---
+
+## Phase 5: Capture and memory review
+
+To capture Codex traffic through Agent Inspector, route a model client through:
+
+\`\`\`text
+http://localhost:${port}/proxy
+\`\`\`
+
+For Anthropic-compatible tools, set \`ANTHROPIC_BASE_URL=http://localhost:${port}/proxy\`. For OpenAI-compatible tools, set \`OPENAI_BASE_URL=http://localhost:${port}/proxy\`.
+
+For a Provider Test memory probe, run a provider test in the Agent Inspector UI:
+
+1. Open \`http://localhost:${port}\`.
+2. Go to Settings -> Providers.
+3. Add or edit a Provider.
+4. Run Test.
+5. Check the \`provider-test\` session.
+
+Then ask Codex:
+
+\`\`\`text
+Use Agent Inspector to create knowledge candidates for the provider-test session, then list the candidates.
+\`\`\`
+
+Expected flow:
+
+- Raw Trace stays in Agent Inspector logs.
+- Session Episode is reconstructed from the session.
+- Memory Candidate is generated for review.
+- Promotion to OpenClaw happens only after review through Agent Inspector.
+
+Stop after showing candidates unless the user explicitly approves promotion.
+`;
+}

package/src/cli.ts

@@ -10,6 +10,9 @@ const __dirname = dirname(__filename);
 
 const DEFAULT_PORT = 25947;
 const LOCAL_PROBE_TIMEOUT_MS = 2000;
+const BRANDED_WINDOWS_RUNTIME_EXE = "agent-inspector.exe";
+
+process.title = "Agent Inspector";
 
 /**
  * Subcommand router. The legacy one-liner UX (`agent-inspector` with no args,
@@ -123,6 +126,18 @@ function waitForProcessExit(child: ChildProcess): Promise<number> {
   });
 }
 
+type ServerCommand = {
+  command: string;
+  args: string[];
+};
+
+function resolveServerCommand(outputDir: string, serverPath: string): ServerCommand {
+  const brandedRuntime = join(outputDir, BRANDED_WINDOWS_RUNTIME_EXE);
+  return process.platform === "win32" && existsSync(brandedRuntime)
+    ? { command: brandedRuntime, args: [serverPath] }
+    : { command: process.execPath, args: [serverPath] };
+}
+
 async function runStart(args: string[]): Promise<void> {
   const envPort = process.env["PORT"];
   const portDefault = envPort !== undefined ? Number(envPort) : DEFAULT_PORT;
@@ -298,8 +313,9 @@ async function runStart(args: string[]): Promise<void> {
   // Compute server path
   const outputDir = __dirname;
   const serverPath = join(outputDir, "../.output/server/index.mjs");
+  const serverCommand = resolveServerCommand(outputDir, serverPath);
 
-  // Start server with node
+  // Start the server with the branded Windows runtime when postinstall created it.
   const serverEnv = { ...process.env };
   if (configDir !== undefined) {
     // Normalize MSYS / Git Bash paths to Windows native form.
@@ -323,7 +339,7 @@ async function runStart(args: string[]): Promise<void> {
   if (providersJson !== undefined) {
     serverEnv["AGENT_INSPECTOR_PROVIDERS_JSON"] = providersJson;
   }
-  const serverProcess = spawn(process.execPath, [serverPath], {
+  const serverProcess = spawn(serverCommand.command, serverCommand.args, {
     stdio: background ? ["ignore", "ignore", "ignore"] : "inherit",
     detached: background,
     env: serverEnv,

package/src/components/providers/ProviderCard.tsx

@@ -1,4 +1,4 @@
-import { type JSX, type ReactNode, useCallback, useRef, useState } from "react";
+import { type JSX, type ReactNode, useState } from "react";
 import { Button } from "../ui/button";
 import { Tooltip, TooltipTrigger, TooltipContent, TooltipProvider } from "../ui/tooltip";
 import {
@@ -235,31 +235,6 @@ export function ProviderCard({
   const [showApiKey, setShowApiKey] = useState(false);
   const [copied, setCopied] = useState(false);
   const [showModelResults, setShowModelResults] = useState(false);
-  const hasLoggedRef = useRef<string | null>(null);
-  const lastTestedAtRef = useRef<string | undefined>(undefined);
-
-  // Reset log state when new test results arrive
-  if (testResults?.testedAt !== undefined && testResults.testedAt !== lastTestedAtRef.current) {
-    lastTestedAtRef.current = testResults.testedAt;
-    hasLoggedRef.current = null;
-  }
-
-  // Call log API when user expands model test results for the first time
-  const handleToggleModelResults = useCallback(() => {
-    setShowModelResults((v) => {
-      const next = !v;
-      if (next && hasLoggedRef.current === null && testResults?.models !== undefined) {
-        hasLoggedRef.current = testResults.testedAt ?? "";
-        // Fire-and-forget: commit test results to dashboard log
-        void fetch(`/api/providers/${provider.id}/test/log`, {
-          method: "POST",
-          headers: { "Content-Type": "application/json" },
-          body: JSON.stringify(testResults),
-        });
-      }
-      return next;
-    });
-  }, [provider.id, testResults]);
 
   function handleCopy() {
     navigator.clipboard.writeText(provider.apiKey).catch(() => {});
@@ -382,7 +357,7 @@ export function ProviderCard({
         <div className="border-t pt-2">
           <button
             type="button"
-            onClick={handleToggleModelResults}
+            onClick={() => setShowModelResults((value) => !value)}
             className="text-xs text-muted-foreground hover:text-foreground transition-colors flex items-center gap-1"
           >
             <span className="font-mono">{showModelResults ? "▾" : "▸"}</span>

package/src/components/providers/ProvidersPanel.tsx

@@ -54,6 +54,21 @@ function createProviderPayload(data: ProviderFormData) {
   };
 }
 
+async function persistProviderTestLog(providerId: string, results: TestResults): Promise<void> {
+  if (results.models === undefined) {
+    return;
+  }
+  try {
+    await fetch(`/api/providers/${providerId}/test/log`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(results),
+    });
+  } catch {
+    // Provider connection status is primary; log persistence is best-effort.
+  }
+}
+
 type ProvidersPanelProps = {
   externalProviders?: ProviderConfig[];
   isLoading?: boolean;
@@ -227,6 +242,7 @@ export function ProvidersPanel({
         if (res.ok) {
           const results = await parseJsonResponse(res, ProviderTestResultsSchema);
           updateTestResults(providerId, results);
+          await persistProviderTestLog(providerId, results);
         } else {
           updateTestResults(
             providerId,