@mrclrchtr/supi-antigravity 6.4.0

package/src/process/event-values.ts

@@ -0,0 +1,279 @@
+import { createHash } from "node:crypto";
+
+const MAX_SAFE_TEXT = 64 * 1024;
+const MAX_TOOL_NAME = 80;
+const MAX_ID_LENGTH = 512;
+
+export const SUCCESS_STATES: ReadonlySet<string> = new Set([
+  "success",
+  "succeeded",
+  "done",
+  "completed",
+  "complete",
+  "ok",
+]);
+export const ERROR_STATES: ReadonlySet<string> = new Set([
+  "error",
+  "failed",
+  "failure",
+  "aborted",
+  "cancelled",
+  "canceled",
+  "timeout",
+]);
+
+export function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+export function safeString(value: unknown, maxLength = MAX_SAFE_TEXT): string | undefined {
+  if (typeof value !== "string") return undefined;
+  const trimmed = value.trim();
+  return trimmed.length > 0 && trimmed.length <= maxLength ? trimmed : undefined;
+}
+
+export function eventType(event: Record<string, unknown>): string {
+  return (safeString(event.type, 40) ?? safeString(event.event, 40) ?? "").toLowerCase();
+}
+
+export function eventStatus(event: Record<string, unknown>): string | undefined {
+  if (
+    event.is_error === true ||
+    event.isError === true ||
+    (event.error !== undefined && event.error !== null)
+  ) {
+    return "error";
+  }
+  const direct = safeString(event.status, 40) ?? safeString(event.subtype, 40);
+  if (direct) return direct.toLowerCase();
+  if (event.ok === true || event.success === true) return "success";
+  return undefined;
+}
+
+export function isSuccessStatus(status: string | undefined): boolean {
+  return status === undefined || SUCCESS_STATES.has(status);
+}
+
+export function isErrorStatus(status: string | undefined): boolean {
+  return status !== undefined && ERROR_STATES.has(status);
+}
+
+export function eventId(event: Record<string, unknown>): string | undefined {
+  const sources = [
+    event,
+    isRecord(event.tool_call) ? event.tool_call : undefined,
+    isRecord(event.toolCall) ? event.toolCall : undefined,
+    isRecord(event.tool_use) ? event.tool_use : undefined,
+    isRecord(event.toolUse) ? event.toolUse : undefined,
+  ];
+  for (const source of sources) {
+    if (!source) continue;
+    for (const key of [
+      "tool_use_id",
+      "toolUseId",
+      "tool_call_id",
+      "toolCallId",
+      "step_index",
+      "stepIndex",
+      "id",
+    ]) {
+      const value = safeIdentifier(source[key]);
+      if (value) return value;
+    }
+  }
+  return undefined;
+}
+
+export function conversationId(event: Record<string, unknown>): string | undefined {
+  for (const key of ["session_id", "sessionId", "conversation_id", "conversationId"]) {
+    const value = safeString(event[key], MAX_ID_LENGTH);
+    if (value) return value;
+  }
+  for (const nested of [event.session, event.conversation]) {
+    if (!isRecord(nested)) continue;
+    const value = conversationId(nested);
+    if (value) return value;
+  }
+  return undefined;
+}
+
+export function toolName(event: Record<string, unknown>): string | undefined {
+  const sources = [
+    event,
+    isRecord(event.tool) ? event.tool : undefined,
+    isRecord(event.tool_call) ? event.tool_call : undefined,
+    isRecord(event.toolCall) ? event.toolCall : undefined,
+    isRecord(event.tool_use) ? event.tool_use : undefined,
+    isRecord(event.toolUse) ? event.toolUse : undefined,
+    isRecord(event.step_update) ? event.step_update : undefined,
+  ];
+  for (const source of sources) {
+    const name = source ? nameFromSource(source) : undefined;
+    if (name) return name;
+  }
+  return undefined;
+}
+
+function nameFromSource(source: Record<string, unknown>): string | undefined {
+  for (const key of ["tool_name", "toolName", "name"]) {
+    const value = safeString(source[key], MAX_TOOL_NAME);
+    if (value) return normalizeToolName(value);
+  }
+  const functionValue = isRecord(source.function)
+    ? safeString(source.function.name, MAX_TOOL_NAME)
+    : undefined;
+  return functionValue ? normalizeToolName(functionValue) : undefined;
+}
+
+export function normalizeToolName(value: string): string {
+  return value
+    .toLowerCase()
+    .replace(/[-\s]+/g, "_")
+    .slice(0, MAX_TOOL_NAME);
+}
+
+function safeIdentifier(value: unknown): string | undefined {
+  if (typeof value === "number" && Number.isSafeInteger(value) && value >= 0) {
+    return String(value);
+  }
+  return safeString(value, MAX_ID_LENGTH);
+}
+
+export function toolInput(event: Record<string, unknown>): Record<string, unknown> | undefined {
+  const nested = [
+    event.tool_call,
+    event.toolCall,
+    event.tool_use,
+    event.toolUse,
+    event.tool,
+    event.input,
+    event.arguments,
+    event.tool_info,
+    event.toolInfo,
+  ];
+  for (const value of nested) {
+    const input = inputFromValue(value);
+    if (input) return input;
+  }
+  return undefined;
+}
+
+function inputFromValue(value: unknown): Record<string, unknown> | undefined {
+  if (!isRecord(value)) return undefined;
+  if (isRecord(value.input)) return value.input;
+  if (isRecord(value.arguments)) return value.arguments;
+  if (isRecord(value.args)) return value.args;
+  if (isRecord(value.parameters)) return value.parameters;
+  return value;
+}
+
+export function extractUrl(value: unknown): string | undefined {
+  return readBoundedField(value, ["url", "uri", "link"], (candidate) =>
+    /^https?:\/\//i.test(candidate),
+  );
+}
+
+export function extractWorkspacePath(value: unknown): string | undefined {
+  return readBoundedField(value, [
+    "path",
+    "file",
+    "file_path",
+    "relative_path",
+    "directory_path",
+    "search_path",
+    "search_directory",
+    "absolute_path",
+    "directory",
+  ]);
+}
+
+function readBoundedField(
+  value: unknown,
+  names: readonly string[],
+  predicate: (candidate: string) => boolean = () => true,
+): string | undefined {
+  if (!isRecord(value)) return undefined;
+  const fields = Object.entries(value);
+  for (const name of names) {
+    const normalizedName = normalizeFieldName(name);
+    for (const [key, field] of fields) {
+      if (normalizeFieldName(key) !== normalizedName) continue;
+      const candidate = safeString(field, 4_096);
+      if (candidate && predicate(candidate)) return candidate;
+    }
+  }
+  return undefined;
+}
+
+function normalizeFieldName(value: string): string {
+  return value.toLowerCase().replace(/[-_]/g, "");
+}
+
+export function hashEvidence(value: string): string {
+  return createHash("sha256").update(value).digest("hex");
+}
+
+export function answerCandidate(
+  event: Record<string, unknown>,
+): Record<string, unknown> | undefined {
+  const candidates = [
+    event.structured_output,
+    event.structuredOutput,
+    event.output,
+    event.result,
+    event.response,
+    event.data,
+  ];
+  for (const value of candidates) {
+    const candidate = decodeCandidate(value);
+    if (candidate) return selectAnswerFields(candidate);
+  }
+  return hasAnswerFields(event) ? selectAnswerFields(event) : undefined;
+}
+
+function decodeCandidate(value: unknown): Record<string, unknown> | undefined {
+  if (isRecord(value)) return value;
+  const text = safeString(value, MAX_SAFE_TEXT);
+  if (!text) return undefined;
+  try {
+    const parsed: unknown = JSON.parse(text);
+    return isRecord(parsed) ? parsed : undefined;
+  } catch {
+    return undefined;
+  }
+}
+
+function hasAnswerFields(value: Record<string, unknown>): boolean {
+  return "answer" in value && "sources" in value && "workspaceEvidence" in value;
+}
+
+function selectAnswerFields(value: Record<string, unknown>): Record<string, unknown> {
+  return {
+    answer: value.answer,
+    sources: value.sources,
+    workspaceEvidence: value.workspaceEvidence,
+  };
+}
+
+export function isTerminalEvent(event: Record<string, unknown>): boolean {
+  const type = eventType(event);
+  return (
+    ["result", "terminal", "done", "final", "completion", "response"].includes(type) ||
+    event.final === true
+  );
+}
+
+export function isToolResultEvent(event: Record<string, unknown>): boolean {
+  const type = eventType(event);
+  return (
+    type === "tool_result" ||
+    type === "toolresult" ||
+    type === "toolresponse" ||
+    type === "tool_response"
+  );
+}
+
+export function isToolStartEvent(event: Record<string, unknown>): boolean {
+  const type = eventType(event);
+  return type === "tool_use" || type === "tooluse" || type === "tool_call" || type === "toolcall";
+}

package/src/process/events.ts

@@ -0,0 +1,365 @@
+import { isAbsolute, normalize as normalizePath, relative } from "node:path";
+import { isWebToolName, isWorkspaceToolName } from "../activity.ts";
+import { validateAntigravityAnswer } from "../structured-output.ts";
+import type { AntigravityExecutionFacts, AntigravityUsage } from "../types.ts";
+import {
+  answerCandidate,
+  conversationId,
+  eventId,
+  eventStatus,
+  eventType,
+  extractUrl,
+  extractWorkspacePath,
+  hashEvidence,
+  isErrorStatus,
+  isRecord,
+  isSuccessStatus,
+  isTerminalEvent,
+  isToolResultEvent,
+  isToolStartEvent,
+  safeString,
+  toolInput,
+  toolName,
+} from "./event-values.ts";
+import { normalizeProtocolEvent } from "./protocol.ts";
+import { mergeUsage, readUsage } from "./usage.ts";
+
+interface PendingTool {
+  name: string;
+  urlHash?: string;
+  pathHash?: string;
+  observed?: boolean;
+  denied?: boolean;
+}
+
+interface ToolResultClassification {
+  kind: "pending" | "failure" | "success";
+  denied: boolean;
+}
+
+const MAX_COMPLETED_TOOL_IDS = 4_096;
+
+/**
+ * Reduces parsed events to bounded execution facts. Raw events and tool payloads
+ * are not retained after each event is processed.
+ */
+export class AntigravityEventAccumulator {
+  readonly #workspaceDirectory: string | undefined;
+  #pendingTools = new Map<string, PendingTool>();
+  #completedToolIds = new Set<string>();
+  #conversationId: string | undefined;
+  #candidate: Record<string, unknown> | undefined;
+  #terminalSeen = false;
+  #terminalSucceeded = false;
+  #usage: AntigravityUsage | undefined;
+  #toolNames: string[] = [];
+  #toolCounts = new Map<string, number>();
+  #successfulToolNames = new Set<string>();
+  #permissionDenials = 0;
+  #unattributedPermissionDenialSeen = false;
+  #sourceHashes = new Set<string>();
+  #workspacePathHashes = new Set<string>();
+
+  constructor(options: { workspaceDirectory?: string } = {}) {
+    this.#workspaceDirectory = options.workspaceDirectory;
+  }
+
+  /** Consume one already-parsed event. */
+  consume(event: Record<string, unknown>): void {
+    if (this.#terminalSeen)
+      throw new Error("Antigravity returned events after its terminal event.");
+    const normalizedEvent = normalizeProtocolEvent(event);
+    this.#conversationId =
+      conversationId(event) ?? conversationId(normalizedEvent) ?? this.#conversationId;
+    this.#usage = mergeUsage(this.#usage, mergeUsage(readUsage(event), readUsage(normalizedEvent)));
+    const terminal = isTerminalEvent(normalizedEvent);
+    const nestedTools = consumeNestedToolBlocks(this, normalizedEvent);
+    if (nestedTools && !terminal) return;
+
+    if (isToolStartEvent(normalizedEvent)) {
+      this.#rememberToolStart(normalizedEvent);
+      return;
+    }
+    if (isToolResultEvent(normalizedEvent)) {
+      this.#consumeToolResult(normalizedEvent);
+      return;
+    }
+    if (terminal) {
+      this.#consumeTerminal(normalizedEvent);
+      return;
+    }
+
+    const directName = toolName(normalizedEvent);
+    if (directName && isSuccessfulActivity(normalizedEvent)) {
+      this.#recordSuccessfulTool(directName, normalizedEvent);
+    }
+    const denied = isPermissionDenial(normalizedEvent);
+    if (denied && !isNonToolStepUpdate(normalizedEvent)) {
+      const counted = directName
+        ? this.#recordPermissionDenial(directName, normalizedEvent)
+        : this.#recordUnattributedPermissionDenial();
+      if (counted) this.#permissionDenials += 1;
+    }
+  }
+
+  /** Finish the reduction and validate terminal structured output. */
+  finish(): AntigravityExecutionFacts {
+    if (!this.#terminalSeen || !this.#terminalSucceeded) {
+      throw new Error("Antigravity did not return a successful terminal event.");
+    }
+    if (!this.#candidate)
+      throw new Error("Antigravity terminal output was missing structured data.");
+    if (!this.#conversationId) throw new Error("Antigravity did not return a conversation handle.");
+    return {
+      answer: validateAntigravityAnswer(this.#candidate),
+      conversationId: this.#conversationId,
+      ...(this.#usage ? { usage: this.#usage } : {}),
+      observedToolNames: [...this.#toolNames],
+      observedToolCounts: Object.fromEntries(this.#toolCounts),
+      successfulToolNames: [...this.#successfulToolNames],
+      permissionDenials: this.#permissionDenials,
+      observedSourceHashes: [...this.#sourceHashes],
+      observedWorkspacePathHashes: [...this.#workspacePathHashes],
+    };
+  }
+
+  #rememberToolStart(event: Record<string, unknown>): void {
+    const name = toolName(event);
+    if (!name) return;
+    const input = toolInput(event) ?? event;
+    const denied = isPermissionDenial(event);
+    const urlHash = hashValue(extractUrl(input));
+    const path = extractWorkspacePath(input);
+    const pathHash = path ? this.#hashWorkspacePath(path) : undefined;
+    const id = eventId(event);
+    if (id) this.#completedToolIds.delete(id);
+    const previous = id ? this.#pendingTools.get(id) : undefined;
+    const pending = mergePendingTool(
+      {
+        name,
+        observed: true,
+        ...(urlHash ? { urlHash } : {}),
+        ...(pathHash ? { pathHash } : {}),
+        ...(denied ? { denied: true } : {}),
+      },
+      previous,
+    );
+    if (!previous) this.#recordObservedTool(name);
+    if (id) this.#pendingTools.set(id, pending);
+    if (isSuccessfulActivity(event)) this.#recordSuccessfulTool(name, event, pending);
+    if (denied && !previous?.denied) this.#permissionDenials += 1;
+  }
+
+  #consumeToolResult(event: Record<string, unknown>): void {
+    const id = eventId(event);
+    // Without an ID, each result is a distinct observation because duplicates are unknowable.
+    if (id && this.#completedToolIds.has(id)) return;
+    const pending = id ? this.#pendingTools.get(id) : undefined;
+    const name = toolName(event) ?? pending?.name;
+    if (!name) return;
+    const classification = classifyToolResult(event);
+    if (classification.kind === "pending") {
+      this.#recordPendingToolResult(id, name, pending);
+      return;
+    }
+    if (id) this.#completeToolResult(id);
+    if (classification.kind === "failure") {
+      this.#recordFailedToolResult(name, pending, classification.denied);
+      return;
+    }
+    this.#recordSuccessfulTool(name, event, pending);
+  }
+
+  #recordPendingToolResult(
+    id: string | undefined,
+    name: string,
+    pending: PendingTool | undefined,
+  ): void {
+    if (!pending?.observed) this.#recordObservedTool(name);
+    if (id && !pending) this.#pendingTools.set(id, { name, observed: true });
+  }
+
+  #completeToolResult(id: string): void {
+    this.#pendingTools.delete(id);
+    this.#rememberCompletedToolId(id);
+  }
+
+  #recordFailedToolResult(name: string, pending: PendingTool | undefined, denied: boolean): void {
+    if (denied && !pending?.denied) this.#permissionDenials += 1;
+    if (!pending?.observed) this.#recordObservedTool(name);
+  }
+
+  #rememberCompletedToolId(id: string): void {
+    this.#completedToolIds.add(id);
+    if (this.#completedToolIds.size <= MAX_COMPLETED_TOOL_IDS) return;
+    const oldest = this.#completedToolIds.values().next().value;
+    if (typeof oldest === "string") this.#completedToolIds.delete(oldest);
+  }
+
+  #recordObservedTool(name: string): void {
+    this.#toolNames = this.#toolNames.includes(name) ? this.#toolNames : [...this.#toolNames, name];
+    this.#toolCounts.set(name, (this.#toolCounts.get(name) ?? 0) + 1);
+  }
+
+  #recordUnattributedPermissionDenial(): boolean {
+    if (this.#unattributedPermissionDenialSeen) return false;
+    this.#unattributedPermissionDenialSeen = true;
+    return true;
+  }
+
+  #recordPermissionDenial(name: string, event: Record<string, unknown>): boolean {
+    const id = eventId(event);
+    if (id && this.#completedToolIds.has(id)) return false;
+    const pending = id ? this.#pendingTools.get(id) : undefined;
+    if (pending?.denied) return false;
+    if (!pending?.observed) this.#recordObservedTool(name);
+    if (id) {
+      if (pending) pending.denied = true;
+      else this.#pendingTools.set(id, { name, observed: true, denied: true });
+    }
+    return true;
+  }
+
+  #recordSuccessfulTool(name: string, event: Record<string, unknown>, pending?: PendingTool): void {
+    if (!pending?.observed) this.#recordObservedTool(name);
+    this.#successfulToolNames.add(name);
+    const input = toolInput(event) ?? event;
+    const sourceHash = pending?.urlHash ?? hashValue(extractUrl(input));
+    const pathHash = pending?.pathHash ?? this.#hashWorkspacePathValue(extractWorkspacePath(input));
+    if (sourceHash && isWebToolName(name)) this.#sourceHashes.add(sourceHash);
+    if (pathHash && isWorkspaceToolName(name)) this.#workspacePathHashes.add(pathHash);
+  }
+
+  #hashWorkspacePath(value: string): string {
+    return hashEvidence(this.#normalizeWorkspacePath(value));
+  }
+
+  #hashWorkspacePathValue(value: string | undefined): string | undefined {
+    return value ? this.#hashWorkspacePath(value) : undefined;
+  }
+
+  #normalizeWorkspacePath(value: string): string {
+    const normalized = value.replaceAll("\\", "/");
+    if (this.#workspaceDirectory && isAbsolute(normalized)) {
+      const distance = relative(this.#workspaceDirectory, normalized);
+      if (distance && distance !== ".." && !distance.startsWith("../")) {
+        return normalizeWorkspacePath(distance);
+      }
+    }
+    return normalizeWorkspacePath(normalized);
+  }
+
+  #consumeTerminal(event: Record<string, unknown>): void {
+    this.#terminalSeen = true;
+    const status = eventStatus(event);
+    if (isErrorStatus(status) || !hasExplicitSuccess(event, status)) {
+      throw new Error("Antigravity returned a non-success terminal status.");
+    }
+    this.#terminalSucceeded = true;
+    this.#candidate = answerCandidate(event);
+    this.#conversationId = conversationId(event) ?? this.#conversationId;
+  }
+}
+
+function consumeNestedToolBlocks(
+  accumulator: AntigravityEventAccumulator,
+  event: Record<string, unknown>,
+): boolean {
+  const message = isRecord(event.message) ? event.message : undefined;
+  const content = message?.content;
+  if (!Array.isArray(content)) return false;
+  let consumed = false;
+  for (const block of content) {
+    if (!isRecord(block)) continue;
+    const normalizedBlock = normalizeProtocolEvent(block);
+    if (!isToolActivityBlock(normalizedBlock)) continue;
+    accumulator.consume(normalizedBlock);
+    consumed = true;
+  }
+  return consumed;
+}
+
+function isToolActivityBlock(event: Record<string, unknown>): boolean {
+  if (isToolStartEvent(event) || isToolResultEvent(event)) return true;
+  return eventType(event) === "step_update" && !isNonToolStepUpdate(event);
+}
+
+function hasExplicitSuccess(event: Record<string, unknown>, status: string | undefined): boolean {
+  return status !== undefined
+    ? isSuccessStatus(status)
+    : event.is_error === false || event.isError === false || event.success === true;
+}
+
+function isSuccessfulActivity(event: Record<string, unknown>): boolean {
+  const status = eventStatus(event);
+  return (
+    !isErrorStatus(status) &&
+    isSuccessStatus(status) &&
+    (status !== undefined || event.success === true || event.ok === true)
+  );
+}
+
+function isNonToolStepUpdate(event: Record<string, unknown>): boolean {
+  const type = eventType(event);
+  if (!["assistant", "step_update"].includes(type)) return false;
+  const declaredType = safeString(event.step_type ?? event.stepType, 40)?.toLowerCase();
+  if (declaredType) return declaredType !== "tool";
+  return toolName(event) === undefined && !isRecord(event.tool_info) && !isRecord(event.toolInfo);
+}
+
+function classifyToolResult(event: Record<string, unknown>): ToolResultClassification {
+  const status = eventStatus(event);
+  const denied = isPermissionDenial(event);
+  if (denied || isErrorStatus(status)) return { kind: "failure", denied };
+  return { kind: isSuccessStatus(status) ? "success" : "pending", denied };
+}
+
+function isPermissionDenial(event: Record<string, unknown>): boolean {
+  const status = eventStatus(event);
+  if (["denied", "permission_denied", "forbidden", "blocked"].includes(status ?? "")) return true;
+  const type = eventType(event);
+  if (type.includes("permission") || type.includes("denied") || type.includes("blocked"))
+    return true;
+  const hasExplicitFailure =
+    event.is_error === true ||
+    event.isError === true ||
+    isErrorStatus(status) ||
+    event.error !== undefined ||
+    event.reason !== undefined;
+  if (!hasExplicitFailure) return false;
+  const message = [event.error, event.reason, event.message, event.content]
+    .map((value) => safeDenialText(value))
+    .join(" ")
+    .toLowerCase();
+  return message.includes("permission") || message.includes("denied");
+}
+
+function safeDenialText(value: unknown, depth = 0): string {
+  if (depth > 3) return "";
+  if (typeof value === "string") return value.slice(0, 4_000);
+  if (Array.isArray(value)) {
+    return value
+      .slice(0, 20)
+      .map((item) => safeDenialText(item, depth + 1))
+      .join(" ");
+  }
+  if (!isRecord(value)) return "";
+  return ["text", "message", "content", "error", "reason"]
+    .map((key) => safeDenialText(value[key], depth + 1))
+    .join(" ");
+}
+
+function mergePendingTool(current: PendingTool, previous: PendingTool | undefined): PendingTool {
+  if (previous?.urlHash && !current.urlHash) current.urlHash = previous.urlHash;
+  if (previous?.pathHash && !current.pathHash) current.pathHash = previous.pathHash;
+  if (previous?.denied) current.denied = true;
+  return current;
+}
+
+function hashValue(value: string | undefined): string | undefined {
+  return value ? hashEvidence(value) : undefined;
+}
+
+function normalizeWorkspacePath(value: string): string {
+  return normalizePath(value.replaceAll("\\", "/")).replace(/^\.\//, "");
+}