@opengeni/react 0.41.0 → 0.44.1

package/src/timeline/parsers.ts

@@ -210,40 +210,222 @@ export function v4aToGitFileDiff(op: ApplyPatchOperation): GitFileDiff {
   };
 }
 
+const BEGIN_PATCH = "*** Begin Patch";
+const END_PATCH = "*** End Patch";
+const ADD_FILE = "*** Add File: ";
+const DELETE_FILE = "*** Delete File: ";
+const UPDATE_FILE = "*** Update File: ";
+const MOVE_TO = "*** Move to: ";
+
+const APPLY_PATCH_OP_TYPES = new Set(["create_file", "update_file", "delete_file"]);
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+
+/** Freeform / `{ patch }` / command payloads — tolerate leading whitespace. */
+function freeformApplyPatchOps(rawPatch: string): ApplyPatchOperation[] {
+  return parseFreeformApplyPatch(rawPatch.trimStart());
+}
+
+function asApplyPatchOperation(value: unknown): ApplyPatchOperation | null {
+  if (!isRecord(value)) return null;
+  if (typeof value.type !== "string" || !APPLY_PATCH_OP_TYPES.has(value.type)) {
+    return null;
+  }
+  if (typeof value.path !== "string" || !value.path) {
+    return null;
+  }
+  const op: ApplyPatchOperation = {
+    type: value.type as ApplyPatchOperation["type"],
+    path: value.path,
+  };
+  if (typeof value.diff === "string") op.diff = value.diff;
+  if (typeof value.moveTo === "string" && value.moveTo.length > 0) op.moveTo = value.moveTo;
+  return op;
+}
+
+function parseStructuredOperations(payloads: unknown[]): ApplyPatchOperation[] {
+  if (payloads.length === 0) return [];
+  const operations: ApplyPatchOperation[] = [];
+  for (const payload of payloads) {
+    const op = asApplyPatchOperation(payload);
+    if (!op) return [];
+    operations.push(op);
+  }
+  return operations;
+}
+
 /**
- * Extract the `apply_patch` operations from a provider-native tool item's `raw`
- * payload, normalizing the two wire shapes (`raw.operations[]` for a multi-file
- * patch, `raw.operation` for a single op). The single owner of this shape so the
- * renderer and the turn-summary facet counter never drift.
+ * Mirror of `@openai/agents-core` freeform `*** Begin Patch` → ops. Kept here so
+ * the timeline can render Codex function-tool apply_patch without importing the
+ * server SDK package.
  */
-export function applyPatchOps(raw: unknown): ApplyPatchOperation[] {
-  const r = (raw ?? {}) as {
-    operation?: ApplyPatchOperation;
-    operations?: ApplyPatchOperation[];
+export function parseFreeformApplyPatch(rawPatch: string): ApplyPatchOperation[] {
+  const lines = rawPatch.split(/\r?\n/);
+  if (lines.at(-1) === "") lines.pop();
+  if (lines[0] !== BEGIN_PATCH) return [];
+  if (lines.length < 2 || lines.at(-1) !== END_PATCH) return [];
+
+  const operations: ApplyPatchOperation[] = [];
+  let index = 1;
+  while (index < lines.length - 1) {
+    const line = lines[index]!;
+    let parsed: { operation: ApplyPatchOperation; nextIndex: number } | { error: true } | null =
+      null;
+    if (line.startsWith(ADD_FILE)) parsed = parseAddFilePatch(lines, index);
+    else if (line.startsWith(DELETE_FILE)) parsed = parseDeleteFilePatch(lines, index);
+    else if (line.startsWith(UPDATE_FILE)) parsed = parseUpdateFilePatch(lines, index);
+    else return [];
+    if (!parsed || "error" in parsed) return [];
+    operations.push(parsed.operation);
+    index = parsed.nextIndex;
+  }
+  // Match the SDK: Begin/End with no file ops is not a valid patch.
+  return operations.length > 0 ? operations : [];
+}
+
+function parsePatchHeader(line: string, prefix: string): string | null {
+  const path = line.slice(prefix.length).trim();
+  return path || null;
+}
+
+function isFileOperationHeader(line: string): boolean {
+  return line.startsWith(ADD_FILE) || line.startsWith(DELETE_FILE) || line.startsWith(UPDATE_FILE);
+}
+
+function joinDiff(lines: string[]): string {
+  return `${lines.join("\n")}\n`;
+}
+
+function parseAddFilePatch(
+  lines: string[],
+  index: number,
+): { operation: ApplyPatchOperation; nextIndex: number } | { error: true } {
+  const path = parsePatchHeader(lines[index]!, ADD_FILE);
+  if (!path) return { error: true };
+  index += 1;
+  const diffLines: string[] = [];
+  while (index < lines.length - 1 && !isFileOperationHeader(lines[index]!)) {
+    const line = lines[index]!;
+    if (!line.startsWith("+")) return { error: true };
+    diffLines.push(line);
+    index += 1;
+  }
+  if (diffLines.length === 0) return { error: true };
+  return {
+    operation: { type: "create_file", path, diff: joinDiff(diffLines) },
+    nextIndex: index,
   };
-  if (Array.isArray(r.operations)) {
-    return r.operations;
+}
+
+function parseDeleteFilePatch(
+  lines: string[],
+  index: number,
+): { operation: ApplyPatchOperation; nextIndex: number } | { error: true } {
+  const path = parsePatchHeader(lines[index]!, DELETE_FILE);
+  if (!path) return { error: true };
+  index += 1;
+  if (index < lines.length - 1 && !isFileOperationHeader(lines[index]!)) {
+    return { error: true };
+  }
+  return { operation: { type: "delete_file", path }, nextIndex: index };
+}
+
+function parseUpdateFilePatch(
+  lines: string[],
+  index: number,
+): { operation: ApplyPatchOperation; nextIndex: number } | { error: true } {
+  const path = parsePatchHeader(lines[index]!, UPDATE_FILE);
+  if (!path) return { error: true };
+  index += 1;
+  let moveTo: string | undefined;
+  if (index < lines.length - 1 && lines[index]!.startsWith(MOVE_TO)) {
+    const parsedMoveTo = parsePatchHeader(lines[index]!, MOVE_TO);
+    if (!parsedMoveTo) return { error: true };
+    moveTo = parsedMoveTo;
+    index += 1;
+  }
+  const diffLines: string[] = [];
+  while (index < lines.length - 1 && !isFileOperationHeader(lines[index]!)) {
+    diffLines.push(lines[index]!);
+    index += 1;
+  }
+  if (diffLines.length === 0 && !moveTo) return { error: true };
+  return {
+    operation: {
+      type: "update_file",
+      path,
+      diff: diffLines.length > 0 ? joinDiff(diffLines) : "",
+      ...(moveTo ? { moveTo } : {}),
+    },
+    nextIndex: index,
+  };
+}
+
+/**
+ * Normalize every apply_patch payload the Agents SDK accepts into structured
+ * ops — hosted `{ operation }` / `{ operations }`, function-tool `{ patch }`,
+ * `command` tuple, flat op, freeform string, or op array.
+ */
+export function applyPatchOps(raw: unknown): ApplyPatchOperation[] {
+  if (raw == null) return [];
+  if (typeof raw === "string") {
+    const trimmed = raw.trimStart();
+    if (trimmed.startsWith(BEGIN_PATCH)) return freeformApplyPatchOps(trimmed);
+    const parsed = tryParseJson(trimmed);
+    return parsed === undefined ? [] : applyPatchOps(parsed);
+  }
+  if (Array.isArray(raw)) return parseStructuredOperations(raw);
+  if (!isRecord(raw)) return [];
+
+  if (typeof raw.patch === "string") return freeformApplyPatchOps(raw.patch);
+  if (Array.isArray(raw.command)) {
+    const [commandName, patch] = raw.command;
+    if (commandName === "apply_patch" && typeof patch === "string") {
+      return freeformApplyPatchOps(patch);
+    }
   }
-  return r.operation ? [r.operation] : [];
+  // Empty `operations: []` is not authoritative — fall through to operation/flat.
+  if (Array.isArray(raw.operations) && raw.operations.length > 0) {
+    return parseStructuredOperations(raw.operations);
+  }
+  if (raw.operation !== undefined) {
+    const op = asApplyPatchOperation(raw.operation);
+    return op ? [op] : [];
+  }
+  // Flat single op: `{ type, path, diff?, moveTo? }`.
+  const flat = asApplyPatchOperation(raw);
+  return flat ? [flat] : [];
 }
 
-/** Ops from provider `raw`, or from function-tool arguments when raw is empty. */
+/** Ops from provider `raw` and/or function-tool arguments (Codex path). */
 export function applyPatchOpsFromToolItem(item: {
   raw: unknown;
   arguments: unknown;
 }): ApplyPatchOperation[] {
   const fromRaw = applyPatchOps(item.raw);
-  if (fromRaw.length > 0) {
-    return fromRaw;
+  if (fromRaw.length > 0) return fromRaw;
+
+  // function_call envelopes sometimes keep the payload only under raw.arguments.
+  if (isRecord(item.raw)) {
+    const nested = item.raw.arguments ?? item.raw.input;
+    if (nested !== undefined && nested !== item.arguments) {
+      const fromNested = applyPatchOps(nested);
+      if (fromNested.length > 0) return fromNested;
+    }
+  }
+
+  if (item.arguments !== undefined && item.arguments !== null) {
+    return applyPatchOps(item.arguments);
   }
-  const args = parseToolArgs(item.arguments);
-  return applyPatchOps(args);
+  return [];
 }
 
 /**
- * True when a tool item is an `apply_patch_call` — by its provider-native
- * `raw.type` (the live-wire source of truth) or by tool `name` (first-party
- * replays that omit `raw`). Centralizes the rawType-or-name check.
+ * True when a tool item is apply_patch — hosted `raw.type === "apply_patch_call"`,
+ * function-tool `name` `apply_patch` / `apply_patch_call`, or an MCP-prefixed
+ * `…__apply_patch` leaf. Centralizes the rawType-or-name check.
  */
 export function isApplyPatch(item: { name: string; raw: unknown }): boolean {
   const type =

package/src/timeline/projection.ts

@@ -54,6 +54,11 @@ const WORKER_MESSAGE_TOOL = "session_send_message";
  * `"agent"`. That keeps mid-turn goal tools from splitting the step rail with
  * a breakaway GoalRow pill. Non-agent goal events (API, create-session,
  * system auto-pause, continuations) still render as landmarks.
+ *
+ * Solo `goal_continuation` machine-input batches are also suppressed: the
+ * paired `goal.continuation` GoalRow already marks the tick; rendering both
+ * restates the goal text. Mixed batches (continuation + other kinds) still
+ * render as machine-input rows.
  */
 const LANDMARK_ONLY_TOOL_LEAVES = new Set(["memory_save", "memory_correct"]);
 
@@ -140,6 +145,12 @@ export function buildTimeline(events: SessionEvent[]): TimelineItem[] {
       case "system.update.delivered": {
         const inputs = machineInputMembers(payload.members);
         if (inputs.length === 0) break;
+        // Goal continuations already land as `goal.continuation` GoalRows.
+        // A solo continuation batch would duplicate that landmark + dump the
+        // model-facing prompt — skip chrome for that case only.
+        if (inputs.every((member) => member.kind === "goal_continuation")) {
+          break;
+        }
         closeStreamingTail();
         items.push({
           kind: "machine-input-batch",

package/src/timeline/tool-renderers.tsx

@@ -364,12 +364,13 @@ function ApplyPatchRenderer({ item }: ToolRendererProps) {
           </RunningPreview>
         }
       >
-        {ops.map((op) => {
+        {ops.map((op, index) => {
           const file = safeParseOp(op);
+          const key = `${op.type}:${op.path}:${index}`;
           return file ? (
-            <ToolDiff key={op.path} files={[file]} />
+            <ToolDiff key={key} files={[file]} />
           ) : (
-            <div key={op.path}>
+            <div key={key}>
               <p className="mb-1 font-og-mono text-og-xs text-og-fg-muted">{op.path}</p>
               <RawPatch diff={op.diff ?? ""} />
             </div>
@@ -421,10 +422,11 @@ function ApplyPatchRenderer({ item }: ToolRendererProps) {
       >
         {ops.map((op, index) => {
           const file = parsed[index];
+          const key = `${op.type}:${op.path}:${index}`;
           return file ? (
-            <ToolDiff key={op.path} files={[file]} />
+            <ToolDiff key={key} files={[file]} />
           ) : (
-            <div key={op.path}>
+            <div key={key}>
               <p className="mb-1 font-og-mono text-og-xs text-og-fg-muted">{op.path}</p>
               <RawPatch diff={op.diff ?? ""} />
             </div>

package/src/timeline/turn-summary.tsx

@@ -16,7 +16,12 @@ import { MOTION_INSPECT_SCALE } from "../lib/motion-inspect";
 import { useForcedDefaultOpen } from "./disclosure-context";
 import { useEntranceAnimation } from "./entrance";
 import { useFoldMemory, type FoldRestingState } from "./fold-memory";
-import { applyPatchOps, isApplyPatch, mediaPreviewFact, screenshotDataUrl } from "./parsers";
+import {
+  applyPatchOpsFromToolItem,
+  isApplyPatch,
+  mediaPreviewFact,
+  screenshotDataUrl,
+} from "./parsers";
 import { rawTypeOf } from "./registry";
 import type { ActivityItem, ToolCallItem, TurnOutcome } from "./types";
 export type { TurnOutcome } from "./types";
@@ -571,7 +576,7 @@ const BUILT_IN_TURN_SUMMARY_FACETS: readonly TurnSummaryFacet[] = Object.freeze(
       let files = 0;
       for (const item of toolCalls) {
         if (isApplyPatch(item)) {
-          files += applyPatchOps(item.raw).length;
+          files += applyPatchOpsFromToolItem(item).length;
         }
       }
       return files ? { content: `${files} ${files === 1 ? "file" : "files"} edited` } : null;

package/src/voice-recording-owner.ts

@@ -0,0 +1,251 @@
+export const VOICE_RECORDING_OWNER_SESSION_KEY = "opengeni.voice-recording-owner.v1";
+
+const VOICE_RECORDING_OWNER_LOCK_PREFIX = "opengeni.voice-recording-owner:";
+const VOICE_RECORDING_OWNER_CHANNEL = "opengeni.voice-recording-owner.v1";
+const OWNER_LOCK_RELOAD_GRACE_MILLISECONDS = 250;
+const OWNER_LOCK_RELOAD_NAVIGATION_MILLISECONDS = 5_000;
+const OWNER_BROADCAST_PROBE_MILLISECONDS = 100;
+const OWNER_BROADCAST_RELOAD_ATTEMPTS = 10;
+
+export type VoiceRecordingOwnerLease = {
+  ownerId: string;
+  release: () => void;
+};
+
+type UnderlyingOwnerLease = VoiceRecordingOwnerLease;
+
+type OwnerProbeMessage = {
+  type: "voice-recording-owner.probe";
+  ownerId: string;
+  instanceId: string;
+};
+
+type OwnerOccupiedMessage = {
+  type: "voice-recording-owner.occupied";
+  ownerId: string;
+  targetInstanceId: string;
+};
+
+let sharedLeasePromise: Promise<UnderlyingOwnerLease> | null = null;
+let sharedLeaseConsumers = 0;
+
+/**
+ * Acquire one document-scoped owner identity shared by every voice hook in the
+ * current document. The session-stored candidate survives reload, while the
+ * held lock/handshake prevents opener-created or duplicated tabs from reusing
+ * that identity concurrently.
+ */
+export async function acquireDefaultVoiceRecordingOwnerLease(): Promise<VoiceRecordingOwnerLease> {
+  sharedLeaseConsumers += 1;
+  sharedLeasePromise ??= createUnderlyingOwnerLease();
+  let underlying: UnderlyingOwnerLease;
+  try {
+    underlying = await sharedLeasePromise;
+  } catch (error) {
+    sharedLeaseConsumers -= 1;
+    if (sharedLeaseConsumers === 0) sharedLeasePromise = null;
+    throw error;
+  }
+
+  let released = false;
+  return {
+    ownerId: underlying.ownerId,
+    release: () => {
+      if (released) return;
+      released = true;
+      sharedLeaseConsumers = Math.max(0, sharedLeaseConsumers - 1);
+      if (sharedLeaseConsumers === 0) {
+        sharedLeasePromise = null;
+        underlying.release();
+      }
+    },
+  };
+}
+
+async function createUnderlyingOwnerLease(): Promise<UnderlyingOwnerLease> {
+  const candidate = readSessionOwnerId() ?? crypto.randomUUID();
+  const reloadNavigation = isReloadNavigation();
+
+  if (hasWebLocks()) {
+    const retained = await tryAcquireWebLock(
+      candidate,
+      reloadNavigation
+        ? OWNER_LOCK_RELOAD_NAVIGATION_MILLISECONDS
+        : OWNER_LOCK_RELOAD_GRACE_MILLISECONDS,
+    );
+    if (retained) {
+      writeSessionOwnerId(candidate);
+      return retained;
+    }
+
+    const rotated = crypto.randomUUID();
+    writeSessionOwnerId(rotated);
+    const acquired = await tryAcquireWebLock(rotated, OWNER_LOCK_RELOAD_GRACE_MILLISECONDS);
+    if (acquired) return acquired;
+  }
+
+  const broadcastLease = await tryAcquireBroadcastLease(
+    readSessionOwnerId() ?? candidate,
+    reloadNavigation ? OWNER_BROADCAST_RELOAD_ATTEMPTS : 0,
+  );
+  if (broadcastLease) return broadcastLease;
+
+  // Without a cross-document coordination primitive, prefer a fresh
+  // per-document identity over copied session state. Recovery then waits only
+  // for the ordinary stale-owner timeout instead of risking cross-tab access.
+  const ownerId = crypto.randomUUID();
+  writeSessionOwnerId(ownerId);
+  return { ownerId, release: () => undefined };
+}
+
+function hasWebLocks(): boolean {
+  return (
+    typeof navigator !== "undefined" &&
+    navigator.locks !== null &&
+    navigator.locks !== undefined &&
+    typeof navigator.locks.request === "function"
+  );
+}
+
+async function tryAcquireWebLock(
+  ownerId: string,
+  waitMilliseconds: number,
+): Promise<UnderlyingOwnerLease | null> {
+  if (!hasWebLocks()) return null;
+
+  return await new Promise<UnderlyingOwnerLease | null>((resolve) => {
+    const controller = new AbortController();
+    let settled = false;
+    const settle = (lease: UnderlyingOwnerLease | null) => {
+      if (settled) return;
+      settled = true;
+      resolve(lease);
+    };
+    const timeout = setTimeout(() => controller.abort(), waitMilliseconds);
+
+    void navigator.locks
+      .request(
+        `${VOICE_RECORDING_OWNER_LOCK_PREFIX}${ownerId}`,
+        { mode: "exclusive", signal: controller.signal },
+        async () => {
+          clearTimeout(timeout);
+          let releaseLock: (() => void) | null = null;
+          const held = new Promise<void>((release) => {
+            releaseLock = release;
+          });
+          settle({
+            ownerId,
+            release: () => releaseLock?.(),
+          });
+          await held;
+        },
+      )
+      .catch(() => {
+        clearTimeout(timeout);
+        settle(null);
+      });
+  });
+}
+
+async function tryAcquireBroadcastLease(
+  initialOwnerId: string,
+  retainCandidateAttempts: number,
+): Promise<UnderlyingOwnerLease | null> {
+  const BroadcastChannelConstructor =
+    typeof window !== "undefined" ? window.BroadcastChannel : undefined;
+  if (!BroadcastChannelConstructor) return null;
+
+  let ownerId = initialOwnerId;
+  for (let attempt = 0; attempt < retainCandidateAttempts + 3; attempt += 1) {
+    const channel = new BroadcastChannelConstructor(VOICE_RECORDING_OWNER_CHANNEL);
+    const instanceId = crypto.randomUUID();
+    let occupied = false;
+    const onMessage = (event: MessageEvent<unknown>) => {
+      const message = ownerCoordinationMessage(event.data);
+      if (!message || message.ownerId !== ownerId) return;
+      if (message.type === "voice-recording-owner.probe") {
+        if (message.instanceId === instanceId) return;
+        channel.postMessage({
+          type: "voice-recording-owner.occupied",
+          ownerId,
+          targetInstanceId: message.instanceId,
+        } satisfies OwnerOccupiedMessage);
+        return;
+      }
+      if (message.targetInstanceId === instanceId) occupied = true;
+    };
+    channel.addEventListener("message", onMessage);
+    channel.postMessage({
+      type: "voice-recording-owner.probe",
+      ownerId,
+      instanceId,
+    } satisfies OwnerProbeMessage);
+    await delay(OWNER_BROADCAST_PROBE_MILLISECONDS);
+    if (!occupied) {
+      writeSessionOwnerId(ownerId);
+      return {
+        ownerId,
+        release: () => {
+          channel.removeEventListener("message", onMessage);
+          channel.close();
+        },
+      };
+    }
+    channel.removeEventListener("message", onMessage);
+    channel.close();
+    if (attempt < retainCandidateAttempts) continue;
+    ownerId = crypto.randomUUID();
+    writeSessionOwnerId(ownerId);
+  }
+  return null;
+}
+
+function isReloadNavigation(): boolean {
+  if (typeof performance === "undefined") return false;
+  return performance.getEntriesByType("navigation").some((entry) => {
+    return "type" in entry && entry.type === "reload";
+  });
+}
+
+function ownerCoordinationMessage(value: unknown): OwnerProbeMessage | OwnerOccupiedMessage | null {
+  if (!value || typeof value !== "object") return null;
+  const candidate = value as Record<string, unknown>;
+  if (
+    candidate.type === "voice-recording-owner.probe" &&
+    typeof candidate.ownerId === "string" &&
+    typeof candidate.instanceId === "string"
+  ) {
+    return candidate as OwnerProbeMessage;
+  }
+  if (
+    candidate.type === "voice-recording-owner.occupied" &&
+    typeof candidate.ownerId === "string" &&
+    typeof candidate.targetInstanceId === "string"
+  ) {
+    return candidate as OwnerOccupiedMessage;
+  }
+  return null;
+}
+
+function readSessionOwnerId(): string | null {
+  try {
+    return typeof window === "undefined"
+      ? null
+      : window.sessionStorage.getItem(VOICE_RECORDING_OWNER_SESSION_KEY);
+  } catch {
+    return null;
+  }
+}
+
+function writeSessionOwnerId(ownerId: string): void {
+  try {
+    window.sessionStorage.setItem(VOICE_RECORDING_OWNER_SESSION_KEY, ownerId);
+  } catch {
+    // Private/embedded contexts may deny session storage. The held lock or
+    // broadcast lease still keeps the in-memory identity document-scoped.
+  }
+}
+
+function delay(milliseconds: number): Promise<void> {
+  return new Promise((resolve) => setTimeout(resolve, milliseconds));
+}