@opengeni/react 0.44.5 → 0.46.1

package/README.md

@@ -412,6 +412,9 @@ intentional changes should regenerate those snapshots and review the diff.
   "jump to latest" affordance, streaming caret, collapsible activity clusters,
   and worker cards (wire `onOpenSession` to drill into a worker). Pass
   `renderMessageText` to plug a markdown renderer.
+- `UserMessageBody` — the shared lossless rendered-height disclosure for
+  already-sent user text. Use it inside a custom `renderMessageText` user branch
+  so attachments and voice identity remain outside the clipped Markdown region.
 - `SessionStatus` / `StatusDot` — status badges; live states breathe.
 - `FleetTile` — one session in a fleet grid: title, status, model, recency.
 - `ModelPicker` — a compact model dropdown for a composer slot, grouping the

package/dist/{chunk-L3EWO3UK.js → chunk-3PB7MIT6.js}

@@ -1113,9 +1113,31 @@ var VOICE_RECORDING_TIMESLICE_MILLISECONDS = 5e3;
 var VOICE_RECORDING_OWNER_HEARTBEAT_MILLISECONDS = 5e3;
 var VOICE_RECORDING_OWNER_STALE_MILLISECONDS = 3e4;
 var VOICE_RECORDING_CLIENT_MAX_DURATION_SECONDS = 600;
+var VOICE_RECORDING_RESUMABLE_CLIENT_MAX_DURATION_SECONDS = 8 * 60 * 60;
+var VOICE_RECORDING_RECOVERY_STATUS_POLL_MILLISECONDS = 2e3;
+var VOICE_RECORDING_RECOVERY_MAX_MUTATION_DELAY_MILLISECONDS = 3e4;
+var TRANSCRIPTION_RECORDING_RECOVERY_RETRY_AFTER_MILLISECONDS = 5e3;
 var MIME_PREFERENCES = ["audio/webm;codecs=opus", "audio/mp4", "audio/ogg;codecs=opus"];
 var createDefaultVoiceRecordingId = () => crypto.randomUUID();
 var currentDate = () => /* @__PURE__ */ new Date();
+function transcriptionRecoveryMutationDelayMilliseconds(retryAfterMilliseconds, attempt, random = Math.random) {
+  const hint = typeof retryAfterMilliseconds === "number" && Number.isInteger(retryAfterMilliseconds) && retryAfterMilliseconds > 0 ? retryAfterMilliseconds : TRANSCRIPTION_RECORDING_RECOVERY_RETRY_AFTER_MILLISECONDS;
+  const boundedHint = Math.max(
+    500,
+    Math.min(hint, VOICE_RECORDING_RECOVERY_MAX_MUTATION_DELAY_MILLISECONDS)
+  );
+  const exponent = Math.max(0, Math.min(Math.floor(attempt), 6));
+  const exponential = Math.min(
+    VOICE_RECORDING_RECOVERY_MAX_MUTATION_DELAY_MILLISECONDS,
+    boundedHint * 2 ** exponent
+  );
+  const sampledJitter = random();
+  const jitterRatio = Number.isFinite(sampledJitter) ? Math.max(0, Math.min(1, sampledJitter)) : 0;
+  return Math.min(
+    VOICE_RECORDING_RECOVERY_MAX_MUTATION_DELAY_MILLISECONDS,
+    Math.ceil(exponential * (1 + jitterRatio * 0.2))
+  );
+}
 function useVoiceInput({
   client,
   workspaceId,
@@ -1337,8 +1359,10 @@ function useVoiceInput({
   const finalizePersistedRecording = useCallback2(
     async (generation) => {
       const manifest = manifestRef.current;
-      const maxSizeBytes = capability?.maxSizeBytes;
-      if (!manifest || !client || !maxSizeBytes || manifest.workspaceId !== workspaceId) return;
+      const resumable = capability?.resumable && isResumableVoiceInputClient(client) ? capability.resumable : null;
+      const maxSizeBytes = resumable?.maxSizeBytes ?? capability?.maxSizeBytes;
+      if (!manifest || !client || !capability || !maxSizeBytes || manifest.workspaceId !== workspaceId)
+        return;
       const controller = new AbortController();
       controllerRef.current?.abort();
       controllerRef.current = controller;
@@ -1378,16 +1402,12 @@ function useVoiceInput({
           await preserveForRetry(retained, "invalid_audio", generation);
           return;
         }
-        const audio = new Blob(
-          chunks.sort((left, right) => left.chunkNumber - right.chunkNumber).map((chunk) => chunk.audio),
-          { type: transcribing.mimeType }
-        );
-        if (!active()) return;
-        if (audio.size > maxSizeBytes) throw { code: "too_large" };
-        const response = await client.transcribeAudio(workspaceId, {
-          audio,
-          mimeType: audio.type,
-          durationSeconds: transcribing.totalDurationMilliseconds / 1e3,
+        const response = await transcribePersistedRecording({
+          client,
+          workspaceId,
+          capability,
+          manifest: transcribing,
+          chunks,
           signal: controller.signal
         });
         if (!active()) return;
@@ -1428,6 +1448,12 @@ function useVoiceInput({
         }
         if (!active()) return;
         rememberManifest(handedOff);
+        if (resumable && isResumableVoiceInputClient(client)) {
+          await client.discardTranscriptionRecording(workspaceId, handedOff.recordingId, {
+            signal: controller.signal
+          }).catch(() => void 0);
+        }
+        if (!active()) return;
         await store.discard(handedOff.recordingId, ownerIdRef.current ?? void 0).catch(() => void 0);
         if (!active()) return;
         clearVisibleRecording();
@@ -1452,7 +1478,7 @@ function useVoiceInput({
       }
     },
     [
-      capability?.maxSizeBytes,
+      capability,
       clearVisibleRecording,
       client,
       ensureStore,
@@ -1568,7 +1594,8 @@ function useVoiceInput({
           });
           if (!startAttemptIsCurrent()) return;
           rememberManifest(result.manifest);
-          if (result.manifest.totalBytes > capability.maxSizeBytes) {
+          const maxSizeBytes = capability.resumable && isResumableVoiceInputClient(client) ? capability.resumable.maxSizeBytes : capability.maxSizeBytes;
+          if (result.manifest.totalBytes > maxSizeBytes) {
             attemptCaptureLimitError = "too_large";
             if (attemptOwnsSharedCapture()) captureLimitErrorRef.current = "too_large";
             if (recorder.state !== "inactive") recorder.stop();
@@ -1627,7 +1654,10 @@ function useVoiceInput({
       setStatus("recording");
       timerRef.current = setTimeout(
         stop,
-        Math.min(capability.maxDurationSeconds, VOICE_RECORDING_CLIENT_MAX_DURATION_SECONDS) * 1e3
+        Math.min(
+          capability.resumable && isResumableVoiceInputClient(client) ? capability.resumable.maxDurationSeconds : capability.maxDurationSeconds,
+          capability.resumable && isResumableVoiceInputClient(client) ? VOICE_RECORDING_RESUMABLE_CLIENT_MAX_DURATION_SECONDS : VOICE_RECORDING_CLIENT_MAX_DURATION_SECONDS
+        ) * 1e3
       );
       return true;
     } catch (reason) {
@@ -1728,6 +1758,10 @@ function useVoiceInput({
       return;
     }
     if (generation !== generationRef.current) return;
+    if (capability?.resumable && isResumableVoiceInputClient(client)) {
+      await client.discardTranscriptionRecording(workspaceId, handedOff.recordingId).catch(() => void 0);
+    }
+    if (generation !== generationRef.current) return;
     await store.discard(handedOff.recordingId, ownerIdRef.current ?? void 0).catch(() => void 0);
     if (generation !== generationRef.current) return;
     clearVisibleRecording();
@@ -1737,6 +1771,8 @@ function useVoiceInput({
     await loadNextRecoverable(generation);
   }, [
     clearVisibleRecording,
+    capability?.resumable,
+    client,
     ensureStore,
     focusInput,
     loadNextRecoverable,
@@ -1760,6 +1796,10 @@ function useVoiceInput({
     await captureSettled.catch(() => void 0);
     if (generation !== generationRef.current) return;
     if (manifest) {
+      if (capability?.resumable && isResumableVoiceInputClient(client)) {
+        await client.discardTranscriptionRecording(workspaceId, manifest.recordingId).catch(() => void 0);
+      }
+      if (generation !== generationRef.current) return;
       try {
         await (await ensureStore()).discard(manifest.recordingId, ownerIdRef.current ?? void 0);
       } catch {
@@ -1781,10 +1821,13 @@ function useVoiceInput({
   }, [
     clearCaptureRuntime,
     clearVisibleRecording,
+    capability?.resumable,
+    client,
     ensureStore,
     focusInput,
     loadNextRecoverable,
-    rememberManifest
+    rememberManifest,
+    workspaceId
   ]);
   const cancel = useCallback2(() => {
     if (status === "recording" || status === "requesting-permission") {
@@ -1924,6 +1967,184 @@ function useVoiceInput({
     discard
   };
 }
+async function transcribePersistedRecording(input) {
+  const client = input.client;
+  const resumable = input.capability.resumable;
+  const ordered = [...input.chunks].sort((left, right) => left.chunkNumber - right.chunkNumber);
+  if (!resumable || !isResumableVoiceInputClient(client)) {
+    const audio = new Blob(
+      ordered.map((chunk) => chunk.audio),
+      { type: input.manifest.mimeType }
+    );
+    if (audio.size > input.capability.maxSizeBytes) throw { code: "too_large" };
+    return await client.transcribeAudio(input.workspaceId, {
+      audio,
+      mimeType: audio.type,
+      durationSeconds: input.manifest.totalDurationMilliseconds / 1e3,
+      signal: input.signal
+    });
+  }
+  if (input.manifest.totalBytes > resumable.maxSizeBytes || input.manifest.totalDurationMilliseconds > resumable.maxDurationSeconds * 1e3) {
+    throw { code: "too_large" };
+  }
+  if (ordered.some((chunk, index) => chunk.chunkNumber !== index) || ordered.length !== input.manifest.chunkCount) {
+    throw { code: "invalid_audio" };
+  }
+  const finalizeInput = {
+    chunkCount: input.manifest.chunkCount,
+    totalBytes: input.manifest.totalBytes,
+    totalDurationMilliseconds: input.manifest.totalDurationMilliseconds,
+    signal: input.signal
+  };
+  let remote = await client.createTranscriptionRecording(input.workspaceId, {
+    recordingId: input.manifest.recordingId,
+    mimeType: input.manifest.mimeType,
+    signal: input.signal
+  });
+  for (const chunk of ordered) {
+    if (chunk.chunkNumber < remote.recording.nextChunkNumber) continue;
+    if (chunk.chunkNumber !== remote.recording.nextChunkNumber) {
+      throw { code: "invalid_audio" };
+    }
+    if (chunk.byteLength > resumable.maxChunkSizeBytes) throw { code: "too_large" };
+    const uploaded = await client.uploadTranscriptionRecordingChunk(
+      input.workspaceId,
+      input.manifest.recordingId,
+      chunk.chunkNumber,
+      {
+        audio: chunk.audio,
+        mimeType: input.manifest.mimeType,
+        sha256: chunk.sha256,
+        startMilliseconds: chunk.startMilliseconds,
+        durationMilliseconds: chunk.durationMilliseconds,
+        signal: input.signal
+      }
+    );
+    remote = { recording: uploaded.recording, segments: remote.segments };
+  }
+  if (remote.recording.nextChunkNumber !== ordered.length) {
+    throw { code: "invalid_audio" };
+  }
+  remote = await client.finalizeTranscriptionRecording(
+    input.workspaceId,
+    input.manifest.recordingId,
+    finalizeInput
+  );
+  let recoveryMutationAttempt = 0;
+  let recoveryMutationDueAt = 0;
+  const scheduleRecoveryMutation = (response) => {
+    if (response.recording.state !== "segmenting" && response.recording.state !== "transcribing") {
+      return;
+    }
+    recoveryMutationDueAt = Date.now() + transcriptionRecoveryMutationDelayMilliseconds(
+      response.retryAfterMilliseconds,
+      recoveryMutationAttempt
+    );
+    recoveryMutationAttempt += 1;
+  };
+  scheduleRecoveryMutation(remote);
+  for (; ; ) {
+    if (input.signal.aborted) throw new DOMException("Aborted", "AbortError");
+    switch (remote.recording.state) {
+      case "complete":
+        if (remote.recording.transcriptText === null) throw { code: "invalid_audio" };
+        return {
+          text: remote.recording.transcriptText,
+          languages: remote.recording.languages
+        };
+      case "ready":
+        remote = await client.processNextTranscriptionRecordingSegment(
+          input.workspaceId,
+          input.manifest.recordingId,
+          { signal: input.signal }
+        );
+        scheduleRecoveryMutation(remote);
+        break;
+      case "failed": {
+        if (!remote.recording.retryable) {
+          throw { code: remote.recording.errorCode ?? "unknown" };
+        }
+        const retried = remote.recording.segmentCount === 0 ? await client.finalizeTranscriptionRecording(
+          input.workspaceId,
+          input.manifest.recordingId,
+          finalizeInput
+        ) : await client.processNextTranscriptionRecordingSegment(
+          input.workspaceId,
+          input.manifest.recordingId,
+          { signal: input.signal }
+        );
+        if (retried.recording.state === "failed") {
+          throw { code: retried.recording.errorCode ?? "unknown" };
+        }
+        remote = retried;
+        scheduleRecoveryMutation(remote);
+        break;
+      }
+      case "discarded":
+        throw { code: "invalid_audio" };
+      case "uploading":
+        remote = await client.finalizeTranscriptionRecording(
+          input.workspaceId,
+          input.manifest.recordingId,
+          finalizeInput
+        );
+        scheduleRecoveryMutation(remote);
+        break;
+      case "segmenting":
+      case "transcribing":
+        if (Date.now() < recoveryMutationDueAt) {
+          await abortableDelay(
+            Math.min(
+              recoveryMutationDueAt - Date.now(),
+              VOICE_RECORDING_RECOVERY_STATUS_POLL_MILLISECONDS
+            ),
+            input.signal
+          );
+          remote = await client.getTranscriptionRecording(
+            input.workspaceId,
+            input.manifest.recordingId,
+            { signal: input.signal }
+          );
+          break;
+        }
+        if (remote.recording.state === "segmenting") {
+          remote = await client.finalizeTranscriptionRecording(
+            input.workspaceId,
+            input.manifest.recordingId,
+            finalizeInput
+          );
+        } else {
+          remote = await client.processNextTranscriptionRecordingSegment(
+            input.workspaceId,
+            input.manifest.recordingId,
+            { signal: input.signal }
+          );
+        }
+        scheduleRecoveryMutation(remote);
+        break;
+    }
+  }
+}
+function isResumableVoiceInputClient(client) {
+  return Boolean(
+    client && client.createTranscriptionRecording && client.getTranscriptionRecording && client.uploadTranscriptionRecordingChunk && client.finalizeTranscriptionRecording && client.processNextTranscriptionRecordingSegment && client.discardTranscriptionRecording
+  );
+}
+async function abortableDelay(milliseconds, signal) {
+  if (signal.aborted) throw new DOMException("Aborted", "AbortError");
+  await new Promise((resolve, reject) => {
+    const timer = setTimeout(() => {
+      signal.removeEventListener("abort", onAbort);
+      resolve();
+    }, milliseconds);
+    const onAbort = () => {
+      clearTimeout(timer);
+      signal.removeEventListener("abort", onAbort);
+      reject(new DOMException("Aborted", "AbortError"));
+    };
+    signal.addEventListener("abort", onAbort, { once: true });
+  });
+}
 function chooseMimeType(accepted) {
   const normalized = accepted.map((value) => value.trim().toLowerCase());
   return MIME_PREFERENCES.find((mimeType) => {
@@ -2499,7 +2720,7 @@ function ModelPicker({
         disabled: disabled === true,
         "aria-label": label,
         className: cn(
-          "h-8 max-w-[180px] cursor-pointer appearance-none truncate rounded-og-md bg-transparent",
+          "h-8 max-w-[180px] cursor-pointer appearance-none truncate rounded-og-md bg-transparent pointer-coarse:h-11",
           "py-0 pl-2 pr-6 text-[13px] text-og-fg-muted",
           "transition-colors duration-150 hover:bg-og-surface-2 hover:text-og-fg",
           "focus:outline-none focus-visible:outline-none",
@@ -3163,7 +3384,7 @@ var Input = forwardRef(function ComposerInput({ rows = 1, placeholder, className
       "aria-controls": paletteOpen ? controller.listboxId : void 0,
       "aria-activedescendant": paletteOpen ? `${controller.listboxId}-option-${controller.palette.highlight}` : void 0,
       className: cn(
-        "block w-full resize-none bg-transparent px-3.5 pt-3 pb-1 text-og-composer md:px-4 md:text-og-composer-wide",
+        "block w-full resize-none bg-transparent px-3.5 pt-3 pb-1 text-og-composer md:px-4 md:text-og-composer-wide pointer-coarse:min-h-11",
         "text-og-fg placeholder:text-og-fg-subtle focus:outline-none focus-visible:outline-none",
         "disabled:cursor-not-allowed disabled:opacity-60",
         className
@@ -3273,7 +3494,7 @@ var AttachButton = forwardRef(
           className: cn(
             "inline-flex size-8 items-center justify-center rounded-og-md",
             "text-og-fg-muted transition-colors duration-150 hover:bg-og-surface-2 hover:text-og-fg",
-            "disabled:cursor-not-allowed disabled:opacity-50 pointer-coarse:size-9",
+            "disabled:cursor-not-allowed disabled:opacity-50 pointer-coarse:size-11",
             className
           ),
           children: children ?? /* @__PURE__ */ jsx3(PaperclipIcon, { className: "size-4" })
@@ -3322,7 +3543,7 @@ var PauseButton = forwardRef(
         disabled: busy,
         "aria-label": ariaLabel ?? controller.messages.pauseAriaLabel,
         className: cn(
-          "inline-flex size-8 items-center justify-center rounded-og-md border border-og-border pointer-coarse:size-9",
+          "inline-flex size-8 items-center justify-center rounded-og-md border border-og-border pointer-coarse:size-11",
           "bg-og-surface-2 text-og-fg-muted transition-colors duration-150",
           "hover:border-og-status-waiting/50 hover:text-og-status-waiting",
           "disabled:opacity-50",
@@ -3348,7 +3569,7 @@ var SendButton = forwardRef(
         "data-og-tip": tip,
         "aria-label": ariaLabel ?? (controller.paused ? controller.messages.sendAndResumeAriaLabel : controller.messages.sendMessageAriaLabel),
         className: cn(
-          "inline-flex size-8 items-center justify-center rounded-og-md pointer-coarse:size-9",
+          "inline-flex size-8 items-center justify-center rounded-og-md pointer-coarse:size-11",
           "bg-og-accent text-og-accent-fg shadow-og-sm",
           "transition-[background-color,transform,opacity] duration-150 ease-og-spring",
           "hover:bg-og-accent-strong active:scale-95",
@@ -4162,4 +4383,4 @@ export {
   Status,
   ComposerTranscriptionControl
 };
-//# sourceMappingURL=chunk-L3EWO3UK.js.map
+//# sourceMappingURL=chunk-3PB7MIT6.js.map