@tonyclaw/agent-inspector 2.0.0

package/src/components/ui/select.tsx

@@ -0,0 +1,178 @@
+"use client";
+
+import * as SelectPrimitive from "@radix-ui/react-select";
+import { CheckIcon, ChevronDownIcon, ChevronUpIcon } from "lucide-react";
+import * as React from "react";
+
+import { cn } from "../../lib/utils";
+
+function Select({
+  ...props
+}: React.ComponentProps<typeof SelectPrimitive.Root>): React.JSX.Element {
+  return <SelectPrimitive.Root data-slot="select" {...props} />;
+}
+
+function SelectGroup({
+  ...props
+}: React.ComponentProps<typeof SelectPrimitive.Group>): React.JSX.Element {
+  return <SelectPrimitive.Group data-slot="select-group" {...props} />;
+}
+
+function SelectValue({
+  ...props
+}: React.ComponentProps<typeof SelectPrimitive.Value>): React.JSX.Element {
+  return <SelectPrimitive.Value data-slot="select-value" {...props} />;
+}
+
+function SelectTrigger({
+  className,
+  size = "default",
+  children,
+  ...props
+}: React.ComponentProps<typeof SelectPrimitive.Trigger> & {
+  size?: "sm" | "default";
+}): React.JSX.Element {
+  return (
+    <SelectPrimitive.Trigger
+      data-slot="select-trigger"
+      data-size={size}
+      className={cn(
+        "border-input data-[placeholder]:text-muted-foreground [&_svg:not([class*='text-'])]:text-muted-foreground focus-visible:border-ring focus-visible:ring-ring/50 aria-invalid:ring-destructive/20 dark:aria-invalid:ring-destructive/40 aria-invalid:border-destructive dark:bg-input/30 dark:hover:bg-input/50 flex w-fit items-center justify-between gap-2 rounded-md border bg-transparent px-3 py-2 text-sm whitespace-nowrap shadow-xs transition-[color,box-shadow] outline-none focus-visible:ring-[3px] disabled:cursor-not-allowed disabled:opacity-50 data-[size=default]:h-9 data-[size=sm]:h-8 *:data-[slot=select-value]:line-clamp-1 *:data-[slot=select-value]:flex *:data-[slot=select-value]:items-center *:data-[slot=select-value]:gap-2 [&_svg]:pointer-events-none [&_svg]:shrink-0 [&_svg:not([class*='size-'])]:size-4",
+        className,
+      )}
+      {...props}
+    >
+      {children}
+      <SelectPrimitive.Icon asChild>
+        <ChevronDownIcon className="size-4 opacity-50" />
+      </SelectPrimitive.Icon>
+    </SelectPrimitive.Trigger>
+  );
+}
+
+function SelectContent({
+  className,
+  children,
+  position = "popper",
+  align = "center",
+  ...props
+}: React.ComponentProps<typeof SelectPrimitive.Content>): React.JSX.Element {
+  return (
+    <SelectPrimitive.Portal>
+      <SelectPrimitive.Content
+        data-slot="select-content"
+        className={cn(
+          "bg-popover text-popover-foreground data-[state=open]:animate-in data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=open]:fade-in-0 data-[state=closed]:zoom-out-95 data-[state=open]:zoom-in-95 data-[side=bottom]:slide-in-from-top-2 data-[side=left]:slide-in-from-right-2 data-[side=right]:slide-in-from-left-2 data-[side=top]:slide-in-from-bottom-2 relative z-50 max-h-(--radix-select-content-available-height) min-w-[8rem] origin-(--radix-select-content-transform-origin) overflow-x-hidden overflow-y-auto rounded-md border shadow-md",
+          position === "popper" &&
+            "data-[side=bottom]:translate-y-1 data-[side=left]:-translate-x-1 data-[side=right]:translate-x-1 data-[side=top]:-translate-y-1",
+          className,
+        )}
+        position={position}
+        align={align}
+        {...props}
+      >
+        <SelectScrollUpButton />
+        <SelectPrimitive.Viewport
+          className={cn(
+            "p-1",
+            position === "popper" &&
+              "h-[var(--radix-select-trigger-height)] w-full min-w-[var(--radix-select-trigger-width)] scroll-my-1",
+          )}
+        >
+          {children}
+        </SelectPrimitive.Viewport>
+        <SelectScrollDownButton />
+      </SelectPrimitive.Content>
+    </SelectPrimitive.Portal>
+  );
+}
+
+function SelectLabel({
+  className,
+  ...props
+}: React.ComponentProps<typeof SelectPrimitive.Label>): React.JSX.Element {
+  return (
+    <SelectPrimitive.Label
+      data-slot="select-label"
+      className={cn("text-muted-foreground px-2 py-1.5 text-xs", className)}
+      {...props}
+    />
+  );
+}
+
+function SelectItem({
+  className,
+  children,
+  ...props
+}: React.ComponentProps<typeof SelectPrimitive.Item>): React.JSX.Element {
+  return (
+    <SelectPrimitive.Item
+      data-slot="select-item"
+      className={cn(
+        "focus:bg-accent focus:text-accent-foreground [&_svg:not([class*='text-'])]:text-muted-foreground relative flex w-full cursor-default items-center gap-2 rounded-sm py-1.5 pr-8 pl-2 text-sm outline-hidden select-none data-[disabled]:pointer-events-none data-[disabled]:opacity-50 [&_svg]:pointer-events-none [&_svg]:shrink-0 [&_svg:not([class*='size-'])]:size-4 *:[span]:last:flex *:[span]:last:items-center *:[span]:last:gap-2",
+        className,
+      )}
+      {...props}
+    >
+      <span className="absolute right-2 flex size-3.5 items-center justify-center">
+        <SelectPrimitive.ItemIndicator>
+          <CheckIcon className="size-4" />
+        </SelectPrimitive.ItemIndicator>
+      </span>
+      <SelectPrimitive.ItemText>{children}</SelectPrimitive.ItemText>
+    </SelectPrimitive.Item>
+  );
+}
+
+function SelectSeparator({
+  className,
+  ...props
+}: React.ComponentProps<typeof SelectPrimitive.Separator>): React.JSX.Element {
+  return (
+    <SelectPrimitive.Separator
+      data-slot="select-separator"
+      className={cn("bg-border pointer-events-none -mx-1 my-1 h-px", className)}
+      {...props}
+    />
+  );
+}
+
+function SelectScrollUpButton({
+  className,
+  ...props
+}: React.ComponentProps<typeof SelectPrimitive.ScrollUpButton>): React.JSX.Element {
+  return (
+    <SelectPrimitive.ScrollUpButton
+      data-slot="select-scroll-up-button"
+      className={cn("flex cursor-default items-center justify-center py-1", className)}
+      {...props}
+    >
+      <ChevronUpIcon className="size-4" />
+    </SelectPrimitive.ScrollUpButton>
+  );
+}
+
+function SelectScrollDownButton({
+  className,
+  ...props
+}: React.ComponentProps<typeof SelectPrimitive.ScrollDownButton>): React.JSX.Element {
+  return (
+    <SelectPrimitive.ScrollDownButton
+      data-slot="select-scroll-down-button"
+      className={cn("flex cursor-default items-center justify-center py-1", className)}
+      {...props}
+    >
+      <ChevronDownIcon className="size-4" />
+    </SelectPrimitive.ScrollDownButton>
+  );
+}
+
+export {
+  Select,
+  SelectContent,
+  SelectItem,
+  SelectScrollDownButton,
+  SelectScrollUpButton,
+  SelectTrigger,
+  SelectValue,
+};

package/src/components/ui/separator.tsx

@@ -0,0 +1,28 @@
+"use client";
+
+import { Separator as SeparatorPrimitive } from "radix-ui";
+import * as React from "react";
+
+import { cn } from "../../lib/utils";
+
+function Separator({
+  className,
+  orientation = "horizontal",
+  decorative = true,
+  ...props
+}: React.ComponentProps<typeof SeparatorPrimitive.Root>): React.JSX.Element {
+  return (
+    <SeparatorPrimitive.Root
+      data-slot="separator"
+      decorative={decorative}
+      orientation={orientation}
+      className={cn(
+        "bg-border shrink-0 data-[orientation=horizontal]:h-px data-[orientation=horizontal]:w-full data-[orientation=vertical]:h-full data-[orientation=vertical]:w-px",
+        className,
+      )}
+      {...props}
+    />
+  );
+}
+
+export { Separator };

package/src/components/ui/tabs.tsx

@@ -0,0 +1,88 @@
+"use client";
+
+import { cva, type VariantProps } from "class-variance-authority";
+import { Tabs as TabsPrimitive } from "radix-ui";
+import * as React from "react";
+
+import { cn } from "../../lib/utils";
+
+function Tabs({
+  className,
+  orientation = "horizontal",
+  ...props
+}: React.ComponentProps<typeof TabsPrimitive.Root>): React.JSX.Element {
+  return (
+    <TabsPrimitive.Root
+      data-slot="tabs"
+      data-orientation={orientation}
+      orientation={orientation}
+      className={cn("group/tabs flex gap-2 data-[orientation=horizontal]:flex-col", className)}
+      {...props}
+    />
+  );
+}
+
+const tabsListVariants = cva(
+  "rounded-lg p-[3px] group-data-[orientation=horizontal]/tabs:h-9 data-[variant=line]:rounded-none group/tabs-list text-muted-foreground inline-flex w-fit items-center justify-center group-data-[orientation=vertical]/tabs:h-fit group-data-[orientation=vertical]/tabs:flex-col",
+  {
+    variants: {
+      variant: {
+        default: "bg-muted",
+        line: "gap-1 bg-transparent",
+      },
+    },
+    defaultVariants: {
+      variant: "default",
+    },
+  },
+);
+
+function TabsList({
+  className,
+  variant = "default",
+  ...props
+}: React.ComponentProps<typeof TabsPrimitive.List> &
+  VariantProps<typeof tabsListVariants>): React.JSX.Element {
+  return (
+    <TabsPrimitive.List
+      data-slot="tabs-list"
+      data-variant={variant}
+      className={cn(tabsListVariants({ variant }), className)}
+      {...props}
+    />
+  );
+}
+
+function TabsTrigger({
+  className,
+  ...props
+}: React.ComponentProps<typeof TabsPrimitive.Trigger>): React.JSX.Element {
+  return (
+    <TabsPrimitive.Trigger
+      data-slot="tabs-trigger"
+      className={cn(
+        "focus-visible:border-ring focus-visible:ring-ring/50 focus-visible:outline-ring text-foreground/60 hover:text-foreground dark:text-muted-foreground dark:hover:text-foreground relative inline-flex h-[calc(100%-1px)] flex-1 items-center justify-center gap-1.5 rounded-md border border-transparent px-2 py-1 text-sm font-medium whitespace-nowrap transition-all group-data-[orientation=vertical]/tabs:w-full group-data-[orientation=vertical]/tabs:justify-start focus-visible:ring-[3px] focus-visible:outline-1 disabled:pointer-events-none disabled:opacity-50 group-data-[variant=default]/tabs-list:data-[state=active]:shadow-sm group-data-[variant=line]/tabs-list:data-[state=active]:shadow-none [&_svg]:pointer-events-none [&_svg]:shrink-0 [&_svg:not([class*='size-'])]:size-4",
+        "group-data-[variant=line]/tabs-list:bg-transparent group-data-[variant=line]/tabs-list:data-[state=active]:bg-transparent dark:group-data-[variant=line]/tabs-list:data-[state=active]:border-transparent dark:group-data-[variant=line]/tabs-list:data-[state=active]:bg-transparent",
+        "data-[state=active]:bg-background dark:data-[state=active]:text-foreground dark:data-[state=active]:border-input dark:data-[state=active]:bg-input/30 data-[state=active]:text-foreground",
+        "after:bg-foreground after:absolute after:opacity-0 after:transition-opacity group-data-[orientation=horizontal]/tabs:after:inset-x-0 group-data-[orientation=horizontal]/tabs:after:bottom-[-5px] group-data-[orientation=horizontal]/tabs:after:h-0.5 group-data-[orientation=vertical]/tabs:after:inset-y-0 group-data-[orientation=vertical]/tabs:after:-right-1 group-data-[orientation=vertical]/tabs:after:w-0.5 group-data-[variant=line]/tabs-list:data-[state=active]:after:opacity-100",
+        className,
+      )}
+      {...props}
+    />
+  );
+}
+
+function TabsContent({
+  className,
+  ...props
+}: React.ComponentProps<typeof TabsPrimitive.Content>): React.JSX.Element {
+  return (
+    <TabsPrimitive.Content
+      data-slot="tabs-content"
+      className={cn("flex-1 outline-none", className)}
+      {...props}
+    />
+  );
+}
+
+export { Tabs, TabsList, TabsTrigger, TabsContent, tabsListVariants };

package/src/components/ui/tooltip.tsx

@@ -0,0 +1,51 @@
+import { Tooltip as TooltipPrimitive } from "radix-ui";
+import * as React from "react";
+
+import { cn } from "../../lib/utils";
+
+function TooltipProvider({
+  delayDuration = 0,
+  ...props
+}: React.ComponentProps<typeof TooltipPrimitive.Provider>) {
+  return (
+    <TooltipPrimitive.Provider
+      data-slot="tooltip-provider"
+      delayDuration={delayDuration}
+      {...props}
+    />
+  );
+}
+
+function Tooltip({ ...props }: React.ComponentProps<typeof TooltipPrimitive.Root>) {
+  return <TooltipPrimitive.Root data-slot="tooltip" {...props} />;
+}
+
+function TooltipTrigger({ ...props }: React.ComponentProps<typeof TooltipPrimitive.Trigger>) {
+  return <TooltipPrimitive.Trigger data-slot="tooltip-trigger" {...props} />;
+}
+
+function TooltipContent({
+  className,
+  sideOffset = 0,
+  children,
+  ...props
+}: React.ComponentProps<typeof TooltipPrimitive.Content>) {
+  return (
+    <TooltipPrimitive.Portal>
+      <TooltipPrimitive.Content
+        data-slot="tooltip-content"
+        sideOffset={sideOffset}
+        className={cn(
+          "bg-foreground text-background animate-in fade-in-0 zoom-in-95 data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=closed]:zoom-out-95 data-[side=bottom]:slide-in-from-top-2 data-[side=left]:slide-in-from-right-2 data-[side=right]:slide-in-from-left-2 data-[side=top]:slide-in-from-bottom-2 z-50 w-fit origin-(--radix-tooltip-content-transform-origin) rounded-md px-3 py-1.5 text-xs text-balance",
+          className,
+        )}
+        {...props}
+      >
+        {children}
+        <TooltipPrimitive.Arrow className="bg-foreground fill-foreground z-50 size-2.5 translate-y-[calc(-50%_-_2px)] rotate-45 rounded-[2px]" />
+      </TooltipPrimitive.Content>
+    </TooltipPrimitive.Portal>
+  );
+}
+
+export { Tooltip, TooltipTrigger, TooltipContent, TooltipProvider };

package/src/index.css

@@ -0,0 +1,11 @@
+@import "../styles/globals.css";
+
+@layer base {
+  :root {
+    @apply font-sans;
+  }
+
+  body {
+    @apply min-w-[320px] min-h-screen m-0 bg-background text-foreground;
+  }
+}

package/src/knowledge/candidateStore.ts

@@ -0,0 +1,63 @@
+import type { KnowledgeCandidate } from "./types";
+
+const candidates = new Map<string, KnowledgeCandidate>();
+
+export function listCandidates(): KnowledgeCandidate[] {
+  return [...candidates.values()].sort((a, b) => b.updatedAt.localeCompare(a.updatedAt));
+}
+
+export function getCandidate(id: string): KnowledgeCandidate | null {
+  return candidates.get(id) ?? null;
+}
+
+export function saveCandidates(items: KnowledgeCandidate[]): KnowledgeCandidate[] {
+  for (const item of items) {
+    const existing = candidates.get(item.id);
+    if (existing === undefined) {
+      candidates.set(item.id, item);
+    } else {
+      candidates.set(item.id, {
+        ...item,
+        status: existing.status,
+        createdAt: existing.createdAt,
+        openClawMemoryId: existing.openClawMemoryId,
+        error: existing.error,
+      });
+    }
+  }
+  return items.map((item) => candidates.get(item.id) ?? item);
+}
+
+export function markCandidatePromoted(
+  id: string,
+  memoryId: string | null,
+): KnowledgeCandidate | null {
+  const existing = candidates.get(id);
+  if (existing === undefined) return null;
+  const updated: KnowledgeCandidate = {
+    ...existing,
+    status: "promoted",
+    openClawMemoryId: memoryId,
+    error: null,
+    updatedAt: new Date().toISOString(),
+  };
+  candidates.set(id, updated);
+  return updated;
+}
+
+export function markCandidateFailed(id: string, error: string): KnowledgeCandidate | null {
+  const existing = candidates.get(id);
+  if (existing === undefined) return null;
+  const updated: KnowledgeCandidate = {
+    ...existing,
+    status: "failed",
+    error,
+    updatedAt: new Date().toISOString(),
+  };
+  candidates.set(id, updated);
+  return updated;
+}
+
+export function _resetCandidatesForTests(): void {
+  candidates.clear();
+}

package/src/knowledge/distiller.ts

@@ -0,0 +1,98 @@
+import { extractLastUserMessagePreview, extractResponsePreview } from "../mcp/previewExtractor";
+import type { CapturedLog } from "../proxy/schemas";
+import type { KnowledgeCandidate, KnowledgeCandidateType } from "./types";
+import { redactCandidate } from "./redactor";
+
+function uniqueStrings(values: Array<string | null | undefined>): string[] {
+  const set = new Set<string>();
+  for (const value of values) {
+    if (value !== null && value !== undefined && value !== "") {
+      set.add(value);
+    }
+  }
+  return [...set];
+}
+
+function firstProject(logs: CapturedLog[]): string | null {
+  for (const log of logs) {
+    if (log.clientProjectFolder !== null && log.clientProjectFolder !== undefined) {
+      return log.clientProjectFolder;
+    }
+  }
+  return null;
+}
+
+function outcomeFor(logs: CapturedLog[]): string {
+  const hasFailure = logs.some((log) => log.responseStatus !== null && log.responseStatus >= 400);
+  const hasPending = logs.some((log) => log.responseStatus === null);
+  if (hasFailure) return "failure";
+  if (hasPending) return "pending";
+  return "success";
+}
+
+function latestPreview(logs: CapturedLog[], pick: (log: CapturedLog) => string | null): string {
+  for (let i = logs.length - 1; i >= 0; i--) {
+    const log = logs[i];
+    if (log === undefined) continue;
+    const preview = pick(log);
+    if (preview !== null && preview !== "") {
+      return preview;
+    }
+  }
+  return "No text preview available.";
+}
+
+function candidateId(sessionId: string, type: KnowledgeCandidateType, logIds: number[]): string {
+  const first = logIds[0] ?? 0;
+  const last = logIds[logIds.length - 1] ?? first;
+  return `inspector:${sessionId}:${type}:${first}-${last}`;
+}
+
+export function distillSessionCandidates(
+  sessionId: string,
+  logs: CapturedLog[],
+): KnowledgeCandidate[] {
+  if (logs.length === 0) return [];
+
+  const sorted = [...logs].sort((a, b) => a.id - b.id);
+  const logIds = sorted.map((log) => log.id);
+  const models = uniqueStrings(sorted.map((log) => log.model));
+  const project = firstProject(sorted);
+  const outcome = outcomeFor(sorted);
+  const lastUser = latestPreview(sorted, extractLastUserMessagePreview);
+  const response = latestPreview(sorted, extractResponsePreview);
+  const now = new Date().toISOString();
+  const titleProject = project === null ? "agent session" : `${project} agent session`;
+
+  const candidate: KnowledgeCandidate = {
+    id: candidateId(sessionId, "episode", logIds),
+    type: "episode",
+    title: `Episode: ${titleProject}`,
+    content: [
+      `Outcome: ${outcome}.`,
+      `Captured ${String(sorted.length)} log(s) for session ${sessionId}.`,
+      `Models: ${models.length === 0 ? "unknown" : models.join(", ")}.`,
+      `Last user request: ${lastUser}`,
+      `Latest response preview: ${response}`,
+    ].join("\n"),
+    tags: ["agent-inspector", "episode", ...(project === null ? [] : [project])],
+    source: "agent-inspector",
+    sessionId,
+    logIds,
+    evidence: {
+      source: "agent-inspector",
+      sessionId,
+      logIds,
+      project,
+      models,
+    },
+    status: "draft",
+    createdAt: now,
+    updatedAt: now,
+    openClawMemoryId: null,
+    error: null,
+    redaction: { redacted: false, patterns: [] },
+  };
+
+  return [redactCandidate(candidate)];
+}

package/src/knowledge/openclawClient.ts

@@ -0,0 +1,118 @@
+import { z } from "zod";
+import type { KnowledgeCandidate, KnowledgeSearchResponse, OpenClawMemoryPayload } from "./types";
+import { KnowledgeSearchResponseSchema, KnowledgeSearchResultSchema } from "./types";
+import { redactCandidate } from "./redactor";
+
+const OpenClawWriteResponseSchema = z.object({
+  id: z.string().optional(),
+  memoryId: z.string().optional(),
+});
+
+export type PromoteResult =
+  | {
+      success: true;
+      memoryId: string | null;
+    }
+  | {
+      success: false;
+      error: string;
+    };
+
+function getEndpoint(): string | null {
+  const endpoint = process.env["OPENCLAW_MEMORY_URL"] ?? process.env["OPENCLAW_API_URL"];
+  if (endpoint === undefined || endpoint.trim() === "") return null;
+  return endpoint.trim();
+}
+
+function buildMemoryUrl(endpoint: string): string {
+  return endpoint.endsWith("/memories") ? endpoint : `${endpoint.replace(/\/$/, "")}/memories`;
+}
+
+function buildSearchUrl(endpoint: string, query: string, project?: string): string {
+  const url = new URL(`${endpoint.replace(/\/$/, "")}/search`);
+  url.searchParams.set("q", query);
+  if (project !== undefined && project !== "") {
+    url.searchParams.set("project", project);
+  }
+  return url.toString();
+}
+
+function authHeaders(): Headers {
+  const headers = new Headers({ "content-type": "application/json" });
+  const token = process.env["OPENCLAW_API_KEY"];
+  if (token !== undefined && token !== "") {
+    headers.set("authorization", `Bearer ${token}`);
+  }
+  return headers;
+}
+
+export function buildOpenClawPayload(candidate: KnowledgeCandidate): OpenClawMemoryPayload {
+  const sanitized = redactCandidate(candidate);
+  return {
+    idempotencyKey: `inspector:session:${sanitized.sessionId}:candidate:${sanitized.id}`,
+    type: sanitized.type,
+    title: sanitized.title,
+    content: sanitized.content,
+    tags: sanitized.tags,
+    source: "agent-inspector",
+    project: sanitized.evidence.project,
+    evidence: sanitized.evidence,
+  };
+}
+
+export async function promoteToOpenClaw(candidate: KnowledgeCandidate): Promise<PromoteResult> {
+  const endpoint = getEndpoint();
+  if (endpoint === null) {
+    return {
+      success: false,
+      error: "OpenClaw memory backend is not configured. Set OPENCLAW_MEMORY_URL.",
+    };
+  }
+
+  const response = await fetch(buildMemoryUrl(endpoint), {
+    method: "POST",
+    headers: authHeaders(),
+    body: JSON.stringify(buildOpenClawPayload(candidate)),
+  });
+
+  if (!response.ok) {
+    return { success: false, error: `OpenClaw memory write failed with ${response.status}` };
+  }
+
+  const raw: unknown = await response.json().catch(() => ({}));
+  const parsed = OpenClawWriteResponseSchema.safeParse(raw);
+  if (!parsed.success) {
+    return { success: true, memoryId: null };
+  }
+  return { success: true, memoryId: parsed.data.memoryId ?? parsed.data.id ?? null };
+}
+
+export async function searchOpenClaw(
+  query: string,
+  project?: string,
+): Promise<KnowledgeSearchResponse> {
+  const endpoint = getEndpoint();
+  if (endpoint === null) {
+    return {
+      results: [],
+      warning: "OpenClaw memory backend is not configured. Set OPENCLAW_MEMORY_URL.",
+    };
+  }
+
+  const response = await fetch(buildSearchUrl(endpoint, query, project), {
+    method: "GET",
+    headers: authHeaders(),
+  });
+  if (!response.ok) {
+    return { results: [], warning: `OpenClaw search failed with ${response.status}` };
+  }
+
+  const raw: unknown = await response.json().catch(() => ({ results: [] }));
+  const parsed = KnowledgeSearchResponseSchema.safeParse(raw);
+  if (parsed.success) return parsed.data;
+  const arrayParsed = z.array(KnowledgeSearchResultSchema).safeParse(raw);
+  if (arrayParsed.success) {
+    return { results: arrayParsed.data, warning: null };
+  }
+  return { results: [], warning: "OpenClaw search returned an unparseable response." };
+}