@tonyclaw/agent-inspector 3.1.32 → 4.0.2

package/src/contracts/index.ts

@@ -1,59 +0,0 @@
-export { JsonValueSchema, trustAsJsonValue } from "./json";
-export type { JsonValue } from "./json";
-
-export {
-  CaptureIncompleteReasonSchema,
-  CapturedLogSchema,
-  LogBodyChunkSchema,
-  LogIdSchema,
-  LogBodyPartSchema,
-  parseLogId,
-  StreamingChunkSchema,
-  StopReasonSchema,
-  ToolTraceEventSchema,
-} from "./log";
-export type {
-  ApiFormat,
-  CaptureIncompleteReason,
-  CapturedLog,
-  LogBodyChunk,
-  LogId,
-  LogBodyPart,
-  StreamingChunk,
-  StopReason,
-  ToolTraceEvent,
-  TokenUsage,
-} from "./log";
-
-export {
-  AnthropicRequestSchema,
-  AnthropicResponseSchema,
-  SseEventSchema,
-} from "./anthropic";
-export type { AnthropicResponse, ResponseContentBlockType } from "./anthropic";
-
-export {
-  OpenAIChoice,
-  OpenAIChoiceDelta,
-  OpenAIFunctionCall,
-  OpenAIMessage,
-  OpenAIMessageContent,
-  OpenAIRequestSchema,
-  OpenAIResponsesRequestSchema,
-  OpenAIResponsesResponseSchema,
-  OpenAIResponsesSSEventSchema,
-  OpenAIResponsesToolDefinition,
-  OpenAIResponsesUsageSchema,
-  OpenAIResponsesOutputItemSchema,
-  OpenAIResponseSchema,
-  OpenAISSERawChunkSchema,
-  OpenAIToolCallSchema,
-  OpenAIToolDefinition,
-  parseOpenAIResponsesResponse,
-  parseOpenAIResponse,
-} from "./openai";
-export type {
-  OpenAIResponse,
-  OpenAIResponsesResponse,
-  OpenAIToolCall,
-} from "./openai";

package/src/contracts/json.ts

@@ -1,37 +0,0 @@
-import { z } from "zod";
-
-/**
- * Shared JSON value type for API payload fragments and streaming chunks.
- */
-export type JsonValue =
-  | string
-  | number
-  | boolean
-  | null
-  | JsonValue[]
-  | { [key: string]: JsonValue };
-
-export const JsonValueSchema: z.ZodType<JsonValue> = z.lazy(() =>
-  z.union([
-    z.string(),
-    z.number(),
-    z.boolean(),
-    z.null(),
-    z.array(JsonValueSchema),
-    z.record(z.string(), JsonValueSchema),
-  ]),
-);
-
-/**
- * Re-types a value as `JsonValue` without a full recursive walk. A lightweight
- * runtime guard rejects the most dangerous non-JSON types (undefined, bigint,
- * functions) that would crash JSON.stringify downstream. Use when the value
- * has already been validated by Zod or originated from JSON.parse.
- */
-export function trustAsJsonValue<T>(value: T): JsonValue {
-  if (value === undefined || typeof value === "bigint" || typeof value === "function") {
-    return null;
-  }
-  // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-  return value as unknown as JsonValue;
-}

package/src/contracts/log.ts

@@ -1,139 +0,0 @@
-import { z } from "zod";
-import { JsonValueSchema } from "./json";
-
-export type ApiFormat = "anthropic" | "openai" | "unknown";
-
-/**
- * Persisted log ID contract. New captures allocate positive IDs, while zero
- * remains readable for legacy data. Unsafe integers are never valid IDs.
- */
-export const LogIdSchema = z.number().int().nonnegative().max(Number.MAX_SAFE_INTEGER);
-
-export type LogId = z.infer<typeof LogIdSchema>;
-
-/** Parse a decimal path/query/header value using the persisted log ID contract. */
-export function parseLogId(value: string): LogId | null {
-  if (!/^\d+$/.test(value)) return null;
-  const result = LogIdSchema.safeParse(Number(value));
-  return result.success ? result.data : null;
-}
-
-export const CaptureIncompleteReasonSchema = z.enum([
-  "capacity-exceeded",
-  "pipeline-closed",
-  "write-failed",
-  "finalize-failed",
-  "finalize-timeout",
-  "upstream-stream-error",
-  "shutdown",
-]);
-
-export type CaptureIncompleteReason = z.infer<typeof CaptureIncompleteReasonSchema>;
-
-/**
- * A single SSE event from a streaming response.
- */
-export const StreamingChunkSchema = z.object({
-  index: z.number(),
-  timestamp: z.number(),
-  type: z.string(),
-  data: JsonValueSchema,
-});
-
-export type StreamingChunk = z.infer<typeof StreamingChunkSchema>;
-
-export const ToolTraceEventSchema = z.object({
-  id: z.string(),
-  logId: LogIdSchema,
-  index: z.number().int().nonnegative(),
-  provider: z.enum(["anthropic", "openai"]),
-  name: z.string(),
-  argumentsText: z.string().nullable(),
-  argumentsPreview: z.string().nullable(),
-});
-
-export type ToolTraceEvent = z.infer<typeof ToolTraceEventSchema>;
-
-const StopReasonValueSchema = z.enum(["end_turn", "tool_use", "stop", "length"]);
-export const StopReasonSchema = StopReasonValueSchema.nullable();
-export type StopReason = z.infer<typeof StopReasonSchema>;
-
-const StreamingChunksArraySchema = z.object({
-  chunks: z.array(StreamingChunkSchema),
-  truncated: z.boolean().optional().default(false),
-});
-
-export const LogBodyPartSchema = z.enum(["request", "response"]);
-export type LogBodyPart = z.infer<typeof LogBodyPartSchema>;
-
-export const LogBodyChunkSchema = z.object({
-  logId: LogIdSchema,
-  part: LogBodyPartSchema,
-  text: z.string(),
-  offset: z.number().int().nonnegative(),
-  limit: z.number().int().positive(),
-  totalBytes: z.number().int().nonnegative(),
-  textBytes: z.number().int().nonnegative(),
-  nextOffset: z.number().int().nonnegative().nullable(),
-  hasMore: z.boolean(),
-  contentMode: z.enum(["empty", "partial", "full"]),
-});
-
-export type LogBodyChunk = z.infer<typeof LogBodyChunkSchema>;
-
-export const CapturedLogSchema = z.object({
-  id: LogIdSchema,
-  timestamp: z.string(),
-  method: z.string(),
-  path: z.string(),
-  model: z.string().nullable(),
-  sessionId: z.string().nullable(),
-  rawRequestBody: z.string().nullable(),
-  responseStatus: z.number().nullable(),
-  responseText: z.string().nullable(),
-  inputTokens: z.number().nullable(),
-  outputTokens: z.number().nullable(),
-  cacheCreationInputTokens: z.number().nullable(),
-  cacheReadInputTokens: z.number().nullable(),
-  elapsedMs: z.number().nullable(),
-  firstChunkMs: z.number().nullable().optional(),
-  totalStreamMs: z.number().nullable().optional(),
-  tokensPerSecond: z.number().nullable().optional(),
-  streaming: z.boolean(),
-  userAgent: z.string().nullable(),
-  origin: z.string().nullable(),
-  rawHeaders: z.record(z.string(), z.string()).optional(),
-  /** Headers sent to the upstream LLM */
-  headers: z.record(z.string(), z.string()).optional(),
-  apiFormat: z.enum(["anthropic", "openai", "unknown"]).default("unknown"),
-  isTest: z.boolean().optional().default(false),
-  replayOfLogId: LogIdSchema.nullable().optional(),
-  providerName: z.string().nullable().optional(),
-  clientPort: z.number().nullable().optional(),
-  clientPid: z.number().nullable().optional(),
-  clientCwd: z.string().nullable().optional(),
-  clientProjectFolder: z.string().nullable().optional(),
-  streamingChunks: StreamingChunksArraySchema.optional(),
-  streamingChunksPath: z.string().nullable().optional(),
-  rawRequestBodyBytes: z.number().int().nonnegative().nullable().optional(),
-  responseTextBytes: z.number().int().nonnegative().nullable().optional(),
-  bodyContentMode: z.enum(["full", "compact", "truncated"]).optional(),
-  captureIncomplete: z.boolean().optional(),
-  droppedChunks: z.number().int().nonnegative().optional(),
-  droppedBytes: z.number().int().nonnegative().optional(),
-  captureIncompleteReason: CaptureIncompleteReasonSchema.nullable().optional(),
-  warnings: z.array(z.string()).optional(),
-  toolTraceEvents: z.array(ToolTraceEventSchema).optional(),
-  stopReason: StopReasonSchema.optional(),
-  /** Error message from streaming response (e.g., SSE error event) */
-  error: z.string().nullable().optional(),
-});
-
-export type CapturedLog = z.infer<typeof CapturedLogSchema>;
-
-export type TokenUsage = {
-  inputTokens: number | null;
-  outputTokens: number | null;
-  cacheCreationInputTokens: number | null;
-  cacheReadInputTokens: number | null;
-};

package/src/contracts/openai.ts

@@ -1,267 +0,0 @@
-import { z } from "zod";
-import { JsonValueSchema } from "./json";
-
-export const OpenAIMessageContent = z.union([
-  z.string(),
-  z.array(
-    z.discriminatedUnion("type", [
-      z.object({ type: z.literal("text"), text: z.string() }),
-      z.object({
-        type: z.literal("image_url"),
-        image_url: z.object({ url: z.string(), detail: z.string().optional() }),
-      }),
-    ]),
-  ),
-]);
-
-export const OpenAIMessage = z.object({
-  role: z.enum(["system", "user", "assistant", "tool"]),
-  content: OpenAIMessageContent,
-  name: z.string().optional(),
-  reasoning_content: z.string().optional(),
-  thinking: z.string().optional(),
-  think: z.string().optional(),
-});
-
-export const OpenAIFunctionCall = z.object({
-  name: z.string(),
-  arguments: z.string(),
-});
-
-export const OpenAIToolCallSchema = z.object({
-  index: z.number().optional(),
-  id: z.string().optional(),
-  type: z.literal("function").optional(),
-  function: z.object({
-    name: z.string().optional(),
-    arguments: z.string().optional(),
-  }),
-});
-
-export type OpenAIToolCall = z.infer<typeof OpenAIToolCallSchema>;
-
-const OpenAIMessageWithFunctionCall = OpenAIMessage.extend({
-  content: z
-    .union([z.string(), z.array(z.object({ type: z.literal("text"), text: z.string() }))])
-    .optional(),
-  function_call: OpenAIFunctionCall.optional(),
-  tool_calls: z.array(OpenAIToolCallSchema).optional(),
-});
-
-export const OpenAIToolDefinition = z.object({
-  type: z.literal("function"),
-  function: z.object({
-    name: z.string(),
-    description: z.string().optional(),
-    parameters: z.record(z.string(), JsonValueSchema),
-  }),
-});
-
-export const OpenAIRequestSchema = z.object({
-  model: z.string(),
-  messages: z.array(OpenAIMessage),
-  temperature: z.number().optional(),
-  max_tokens: z.number().optional(),
-  stream: z.boolean().optional(),
-  tools: z.array(OpenAIToolDefinition).optional(),
-  tool_choice: z
-    .union([
-      z.enum(["auto", "none", "required"]),
-      z.object({ type: z.literal("auto") }),
-      z.object({ type: z.literal("none") }),
-      z.object({ type: z.literal("function"), function: z.object({ name: z.string() }) }),
-    ])
-    .optional(),
-  user: z.string().optional(),
-});
-
-export const OpenAIResponsesToolDefinition = z
-  .object({
-    type: z.string(),
-    name: z.string().optional(),
-    description: z.string().optional(),
-    parameters: JsonValueSchema.optional(),
-    function: z
-      .object({
-        name: z.string().optional(),
-        description: z.string().optional(),
-        parameters: JsonValueSchema.optional(),
-      })
-      .optional(),
-  })
-  .passthrough();
-
-export const OpenAIResponsesRequestSchema = z
-  .object({
-    model: z.string(),
-    input: z.unknown().optional(),
-    instructions: z.union([z.string(), z.null()]).optional(),
-    stream: z.boolean().optional(),
-    tools: z.array(OpenAIResponsesToolDefinition).optional(),
-    tool_choice: z.unknown().optional(),
-    max_output_tokens: z.number().optional(),
-    temperature: z.number().optional(),
-    user: z.string().optional(),
-    metadata: z.record(z.string(), z.unknown()).optional(),
-  })
-  .passthrough();
-
-export const OpenAIChoiceDelta = z.object({
-  role: z.enum(["assistant"]).optional(),
-  content: z.string().nullable().optional(),
-  reasoning_content: z.string().nullable().optional(),
-  thinking: z.string().nullable().optional(),
-  think: z.string().nullable().optional(),
-  function_call: z
-    .object({ name: z.string().optional(), arguments: z.string().optional() })
-    .nullable()
-    .optional(),
-  tool_calls: z
-    .array(
-      z.object({
-        index: z.number(),
-        id: z.string().optional(),
-        type: z.literal("function").optional(),
-        function: z.object({
-          name: z.string().optional(),
-          arguments: z.string().optional(),
-        }),
-      }),
-    )
-    .nullable()
-    .optional(),
-});
-
-export const OpenAIChoice = z.object({
-  index: z.number(),
-  message: z
-    .object({
-      role: z.enum(["assistant"]),
-      content: z.string().nullable(),
-      reasoning_content: z.string().optional(),
-      thinking: z.string().optional(),
-      think: z.string().optional(),
-      function_call: z.object({ name: z.string(), arguments: z.string() }).nullable().optional(),
-      tool_calls: z.array(OpenAIToolCallSchema).optional(),
-    })
-    .optional(),
-  delta: OpenAIChoiceDelta.optional(),
-  finish_reason: z.string().nullable(),
-});
-
-export const OpenAIResponseSchema = z
-  .object({
-    id: z.string(),
-    object: z.literal("chat.completion"),
-    created: z.number(),
-    model: z.string(),
-    choices: z.array(OpenAIChoice),
-    usage: z
-      .object({
-        prompt_tokens: z.number().nullable().optional(),
-        completion_tokens: z.number().nullable().optional(),
-        total_tokens: z.number().nullable().optional(),
-      })
-      .passthrough(),
-    service_tier: z.string().nullable().optional(),
-    system_fingerprint: z.string().nullable().optional(),
-  })
-  .passthrough();
-
-export const OpenAISSERawChunkSchema = z
-  .object({
-    id: z.string(),
-    object: z.literal("chat.completion.chunk"),
-    created: z.number(),
-    model: z.string(),
-    choices: z.array(
-      z.object({
-        index: z.number(),
-        delta: OpenAIChoiceDelta,
-        finish_reason: z.string().nullable().optional(),
-      }),
-    ),
-    usage: z
-      .object({
-        prompt_tokens: z.number().nullable().optional(),
-        completion_tokens: z.number().nullable().optional(),
-        total_tokens: z.number().nullable().optional(),
-      })
-      .passthrough()
-      .nullable()
-      .optional(),
-  })
-  .passthrough();
-
-export const OpenAIResponsesUsageSchema = z
-  .object({
-    input_tokens: z.number().nullable().optional(),
-    output_tokens: z.number().nullable().optional(),
-    total_tokens: z.number().nullable().optional(),
-    input_tokens_details: z
-      .object({
-        cached_tokens: z.number().nullable().optional(),
-      })
-      .passthrough()
-      .nullable()
-      .optional(),
-    output_tokens_details: z
-      .object({
-        reasoning_tokens: z.number().nullable().optional(),
-      })
-      .passthrough()
-      .nullable()
-      .optional(),
-  })
-  .passthrough();
-
-export const OpenAIResponsesOutputItemSchema = z
-  .object({
-    type: z.string(),
-  })
-  .passthrough();
-
-export const OpenAIResponsesResponseSchema = z
-  .object({
-    id: z.string(),
-    object: z.literal("response").optional(),
-    created_at: z.number().optional(),
-    status: z.string().nullable().optional(),
-    model: z.string().optional(),
-    output: z.array(OpenAIResponsesOutputItemSchema).optional(),
-    output_text: z.string().optional(),
-    usage: OpenAIResponsesUsageSchema.nullable().optional(),
-    error: z.unknown().optional(),
-  })
-  .passthrough();
-
-export const OpenAIResponsesSSEventSchema = z
-  .object({
-    type: z.string(),
-  })
-  .passthrough();
-
-export type OpenAIResponse = z.infer<typeof OpenAIResponseSchema>;
-export type OpenAIResponsesResponse = z.infer<typeof OpenAIResponsesResponseSchema>;
-
-export function parseOpenAIResponse(rawBody: string): OpenAIResponse | null {
-  try {
-    const json: unknown = JSON.parse(rawBody);
-    const result = OpenAIResponseSchema.safeParse(json);
-    if (result.success) return result.data;
-    return null;
-  } catch {
-    return null;
-  }
-}
-
-export function parseOpenAIResponsesResponse(rawBody: string): OpenAIResponsesResponse | null {
-  try {
-    const json: unknown = JSON.parse(rawBody);
-    const result = OpenAIResponsesResponseSchema.safeParse(json);
-    if (result.success) return result.data;
-    return null;
-  } catch {
-    return null;
-  }
-}

package/src/index.css

@@ -1,11 +0,0 @@
-@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

@@ -1,94 +0,0 @@
-import type { KnowledgeCandidate, KnowledgeCandidateType } from "./types";
-import { redactCandidate } from "./redactor";
-
-export type CandidateDraftUpdate = {
-  type?: KnowledgeCandidateType;
-  title?: string;
-  content?: string;
-  tags?: string[];
-};
-
-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 updateCandidateDraft(
-  id: string,
-  updates: CandidateDraftUpdate,
-): KnowledgeCandidate | null {
-  const existing = candidates.get(id);
-  if (existing === undefined) return null;
-  if (existing.status === "promoted") return null;
-
-  const updated = redactCandidate({
-    ...existing,
-    type: updates.type ?? existing.type,
-    title: updates.title ?? existing.title,
-    content: updates.content ?? existing.content,
-    tags: updates.tags ?? existing.tags,
-    status: "draft",
-    error: null,
-    openClawMemoryId: null,
-    updatedAt: new Date().toISOString(),
-  });
-  candidates.set(id, updated);
-  return updated;
-}
-
-export function _resetCandidatesForTests(): void {
-  candidates.clear();
-}

package/src/knowledge/distiller.ts

@@ -1,98 +0,0 @@
-import { extractLastUserMessagePreview, extractResponsePreview } from "../mcp/previewExtractor";
-import type { CapturedLog } from "../contracts";
-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)];
-}