@opengeni/react 1.4.4 → 1.4.5-canary.37458084490001

package/src/sandbox-label-model.ts

@@ -0,0 +1,41 @@
+/**
+ * User-facing names for where a session's commands run, shared by the web
+ * sandbox switcher and every timeline that labels command rows ("on Cloud
+ * sandbox · …"). No DOM, no React.
+ */
+import type { SandboxBackend } from "@opengeni/sdk";
+import type { MachineView } from "./types/machines";
+
+export const CLOUD_SANDBOX_LABEL = "Cloud sandbox";
+export const NO_SANDBOX_LABEL = "No sandbox";
+export const LOCAL_SANDBOX_LABEL = "Local sandbox";
+
+/**
+ * User-facing name for a session's own managed box. Hosting vendors (Modal,
+ * Daytona, ...) are deployment detail, not something a user chose, so hosted
+ * providers read as the neutral "Cloud sandbox" and the local-dev Docker box as
+ * "Local sandbox". The local backend runs directly on the host, so it keeps the
+ * honest "this computer" instead of implying isolation. Connected Machines keep
+ * their own names.
+ */
+export function sessionSandboxLabel(backend: SandboxBackend | string): string {
+  if (backend === "none") return NO_SANDBOX_LABEL;
+  if (backend === "local") return "this computer";
+  if (backend === "docker") return LOCAL_SANDBOX_LABEL;
+  return CLOUD_SANDBOX_LABEL;
+}
+
+/** Display name for a fleet row: the session's own box never shows its vendor. */
+export function machineDisplayName(
+  machine: Pick<MachineView, "isSessionGroup" | "kind" | "name">,
+): string {
+  return machine.isSessionGroup ? sessionSandboxLabel(machine.kind) : machine.name;
+}
+
+/** The compute label a session timeline shows: the active machine, else the cloud box. */
+export function sessionComputeLabel(
+  machines: readonly Pick<MachineView, "active" | "isSessionGroup" | "kind" | "name">[],
+): string {
+  const active = machines.find((machine) => machine.active);
+  return active ? machineDisplayName(active) : CLOUD_SANDBOX_LABEL;
+}

package/src/session-attention-model.ts

@@ -0,0 +1,59 @@
+import type { SessionEvent } from "@opengeni/sdk";
+
+// Keep this client scheduling predicate aligned with the meaningful-attention
+// predicate in packages/db/src/session-meaningful-events.ts. The server remains
+// authoritative; this only avoids personal-state writes for streaming activity.
+export const SESSION_ATTENTION_EVENT_TYPES: ReadonlySet<string> = new Set([
+  "agent.message.completed",
+  "turn.completed",
+  "turn.failed",
+  "session.requiresAction",
+  "session.humanInput.requested",
+  "tool.auth_needed",
+  "credential.auth_needed",
+  "goal.completed",
+  "goal.paused",
+  "goal.progress",
+  "goal.rewrite.proposed",
+  "rig.setup.failed",
+  "sandbox.operation.failed",
+  "sandbox.box.lost",
+  "workspace.revision.degraded",
+  "machine.op.failed",
+  "machine.link.lost",
+  "session.event.envelope_omitted",
+]);
+
+/**
+ * The latest delivered attention boundary, independent of raw token activity.
+ * A foreground reader acknowledges through this sequence, so streaming flushes
+ * never cause a personal-state write and later activity stays unread.
+ */
+export function sessionAttentionReadThroughSequence(events: readonly SessionEvent[]): number {
+  for (let index = events.length - 1; index >= 0; index -= 1) {
+    const event = events[index]!;
+    if (
+      !SESSION_ATTENTION_EVENT_TYPES.has(event.type) ||
+      event.duplicateOfEventId ||
+      (event.turnAssociation != null && event.turnAssociation !== "current")
+    )
+      continue;
+    const payload =
+      event.payload && typeof event.payload === "object"
+        ? (event.payload as Record<string, unknown>)
+        : {};
+    if (
+      event.type === "agent.message.completed" &&
+      (payload.phase === "commentary" || payload.text == null || payload.text === "")
+    )
+      continue;
+    if (event.type === "turn.completed") {
+      if (Object.hasOwn(payload, "maintenance") || Object.hasOwn(payload, "segmentLimit")) continue;
+      const output = payload.output ?? payload.result;
+      if ((output == null || output === "") && (payload.reply == null || payload.reply === ""))
+        continue;
+    }
+    return event.sequence;
+  }
+  return 0;
+}

package/src/session-feedback-model.ts

@@ -0,0 +1,95 @@
+// Reply and session feedback shared by web and native: the one feedback read
+// per session (with recovery), saved turn ratings, the submission payload with
+// a retained idempotency key, and the dialog copy. No DOM, no React.
+import type {
+  CreateFeedbackRequest,
+  Feedback,
+  FeedbackSentiment,
+  OpenGeniClient,
+} from "@opengeni/sdk";
+
+export type FeedbackClient = Pick<OpenGeniClient, "createFeedback" | "listOwnFeedback">;
+
+/** One shared read per session, with recovery after a transient network failure. */
+export function loadSessionFeedback(
+  client: Pick<OpenGeniClient, "listOwnFeedback">,
+  workspaceId: string,
+  sessionId: string,
+  onLoaded: (result: Awaited<ReturnType<OpenGeniClient["listOwnFeedback"]>>) => void,
+): () => void {
+  let current = true;
+  let delay = 1_000;
+  let timer: ReturnType<typeof setTimeout> | undefined;
+  const load = () => {
+    void client.listOwnFeedback(workspaceId, { sessionId, includeTurns: true }).then(
+      (result) => {
+        if (current) onLoaded(result);
+      },
+      () => {
+        if (!current) return;
+        timer = setTimeout(load, delay);
+        delay = Math.min(delay * 2, 30_000);
+      },
+    );
+  };
+  load();
+  return () => {
+    current = false;
+    clearTimeout(timer);
+  };
+}
+
+/** The first saved rating per turn (the list is newest-first). */
+export function turnRatingsFromFeedback(
+  feedback: readonly Feedback[],
+): Record<string, FeedbackSentiment> {
+  const ratings: Record<string, FeedbackSentiment> = {};
+  for (const entry of feedback) {
+    if (entry.turnId && entry.sentiment && !ratings[entry.turnId])
+      ratings[entry.turnId] = entry.sentiment;
+  }
+  return ratings;
+}
+
+export type FeedbackPayload = Omit<CreateFeedbackRequest, "idempotencyKey">;
+
+/**
+ * The request to send, reusing the previous idempotency key when the user
+ * retries the identical submission (a lost response must not duplicate it).
+ */
+export function feedbackSubmission(
+  payload: FeedbackPayload,
+  previous: CreateFeedbackRequest | null,
+  newKey: () => string,
+): CreateFeedbackRequest {
+  if (
+    previous &&
+    previous.sessionId === payload.sessionId &&
+    previous.turnId === payload.turnId &&
+    previous.sentiment === payload.sentiment &&
+    previous.comment === payload.comment
+  ) {
+    return previous;
+  }
+  return { ...payload, idempotencyKey: newKey() };
+}
+
+export function feedbackDialogCopy(target: {
+  sessionId?: string | undefined;
+  turnId?: string | undefined;
+}) {
+  return {
+    title: target.turnId
+      ? "Rate this reply"
+      : target.sessionId
+        ? "Rate this session"
+        : "Send feedback",
+    description: target.sessionId
+      ? "Share what worked or what could be better."
+      : "Tell us what could make Opengeni better.",
+  };
+}
+
+export function feedbackSentimentLabel(sentiment: FeedbackSentiment): string {
+  return sentiment === "positive" ? "Thumbs up" : "Thumbs down";
+}

package/src/session-list-model.ts

@@ -0,0 +1,327 @@
+// Pure session-list presentation shared by the web app (rail and recent
+// sessions) and native renderers: relative-time labels, recency bucketing
+// (Today / Yesterday / Previous 7 days / Older), the running-first ordering
+// rule, status tones and the compact row metadata. No DOM, no React.
+import {
+  deriveAutomaticSessionTitlePreview,
+  deriveSessionDisplayTitle,
+  sessionTitleIsPending,
+  type ClientModel,
+  type Session,
+  type SessionListEntry,
+  type SessionStatus,
+} from "@opengeni/sdk";
+import { modelDisplayName } from "@opengeni/sdk/model-display";
+import { findPickerRow, type PickerModelRow } from "./model-policy";
+
+/** A list row may be a compact page entry or a complete session response. */
+export type SessionListRow = Session | SessionListEntry;
+
+/**
+ * The title shown for a session: durable agent/user metadata once available,
+ * otherwise a bounded opening-prompt preview while automatic naming is still
+ * pending. Every list, header and row reads identically.
+ */
+export function sessionDisplayTitle(session: SessionListRow): string {
+  return "displayTitle" in session ? session.displayTitle : deriveSessionDisplayTitle(session);
+}
+
+/** The maximum length a session title may be renamed to. */
+export const SESSION_TITLE_MAX_LENGTH = 200;
+
+/**
+ * The value a rename editor seeds from. A safe provisional prompt preview is
+ * editable because it is also what the user sees; the UUID-derived reference
+ * remains an empty draft rather than becoming an accidental rename.
+ */
+export function sessionRenameSeed(session: SessionListRow): string {
+  if ("renameSeed" in session) return session.renameSeed;
+  if (!sessionTitleIsPending(session)) {
+    return session.title?.trim() || "";
+  }
+  return deriveAutomaticSessionTitlePreview(session.initialMessage) ?? "";
+}
+
+/**
+ * Resolve a submitted draft against the current display title. Returns the
+ * trimmed title to persist, or `null` when the edit is a no-op (empty,
+ * unchanged from what is already shown, or still equal to the value that
+ * seeded this edit) and should simply cancel.
+ */
+export function resolveRenameSubmission(
+  draft: string,
+  display: string,
+  editSeed?: string,
+): string | null {
+  const next = draft.trim();
+  if (!next || next === display || (editSeed !== undefined && next === editSeed.trim())) {
+    return null;
+  }
+  return next;
+}
+
+export type SessionRecencyGroup = "today" | "yesterday" | "previous7" | "older";
+
+export const SESSION_GROUP_LABELS: Record<SessionRecencyGroup, string> = {
+  today: "Today",
+  yesterday: "Yesterday",
+  previous7: "Previous 7 days",
+  older: "Older",
+};
+
+/** The render order of recency groups, top → bottom. */
+export const SESSION_GROUP_ORDER: SessionRecencyGroup[] = [
+  "today",
+  "yesterday",
+  "previous7",
+  "older",
+];
+
+/** Live states that earn the pinned-to-top, breathing-dot treatment. */
+const RUNNING_STATUSES = new Set<SessionStatus>([
+  "running",
+  "queued",
+  "waiting_capacity",
+  "recovering",
+  "requires_action",
+]);
+
+export function isRunningStatus(status: SessionStatus): boolean {
+  return RUNNING_STATUSES.has(status);
+}
+
+/** An idle session waiting on its own timer, while its control is active. */
+export function sessionInputWait(
+  session: Pick<SessionListRow, "status" | "effectiveControl" | "inputWait">,
+) {
+  return session.status === "idle" && session.effectiveControl?.state === "active"
+    ? (session.inputWait ?? null)
+    : null;
+}
+
+export function hasActiveEffectiveControl(session: SessionListRow): boolean {
+  return (session.effectiveControl?.state ?? "active") === "active";
+}
+
+export function isEffectivelyRunning(session: SessionListRow): boolean {
+  // Background commands have their own chat indicator, not agent working status.
+  return (
+    hasActiveEffectiveControl(session) &&
+    (isRunningStatus(session.status) || Boolean(sessionInputWait(session)))
+  );
+}
+
+/** Most-recent activity timestamp for a session (updatedAt, then createdAt). */
+export function sessionActivityTime(session: SessionListRow): number {
+  const updated = Date.parse(session.updatedAt);
+  if (!Number.isNaN(updated)) {
+    return updated;
+  }
+  const created = Date.parse(session.createdAt);
+  return Number.isNaN(created) ? 0 : created;
+}
+
+/** Deterministic newest-first ordering for every flat or forest session list. */
+export function compareSessionActivity(left: SessionListRow, right: SessionListRow): number {
+  return sessionActivityTime(right) - sessionActivityTime(left) || right.id.localeCompare(left.id);
+}
+
+/** Deterministic personal-pin order: newest pin first, then descending id. */
+export function compareSessionPins(left: SessionListRow, right: SessionListRow): number {
+  const leftPinnedAt = Date.parse(left.pinnedAt ?? "");
+  const rightPinnedAt = Date.parse(right.pinnedAt ?? "");
+  const leftTime = Number.isNaN(leftPinnedAt) ? 0 : leftPinnedAt;
+  const rightTime = Number.isNaN(rightPinnedAt) ? 0 : rightPinnedAt;
+  return rightTime - leftTime || right.id.localeCompare(left.id);
+}
+
+/** Split explicit personal pins from ordinary rows without changing the input. */
+export function partitionPinnedSessions<T extends SessionListRow>(
+  sessions: T[],
+): {
+  pinned: T[];
+  ordinary: T[];
+} {
+  const pinned: T[] = [];
+  const ordinary: T[] = [];
+  for (const session of sessions) {
+    (session.pinned ? pinned : ordinary).push(session);
+  }
+  return { pinned: pinned.sort(compareSessionPins), ordinary };
+}
+
+/**
+ * Which recency bucket a timestamp falls into, relative to `now`. "Today" and
+ * "Yesterday" are calendar-local; "Previous 7 days" is the rest of the trailing
+ * week; everything earlier is "Older".
+ */
+export function recencyGroupFor(timestampMs: number, now: Date = new Date()): SessionRecencyGroup {
+  const startOfToday = new Date(now.getFullYear(), now.getMonth(), now.getDate()).getTime();
+  const startOfYesterday = startOfToday - 24 * 60 * 60 * 1000;
+  const startOfWeekWindow = startOfToday - 7 * 24 * 60 * 60 * 1000;
+  if (timestampMs >= startOfToday) {
+    return "today";
+  }
+  if (timestampMs >= startOfYesterday) {
+    return "yesterday";
+  }
+  if (timestampMs >= startOfWeekWindow) {
+    return "previous7";
+  }
+  return "older";
+}
+
+export type SessionRecencyBucket<T extends SessionListRow = SessionListRow> = {
+  group: SessionRecencyGroup;
+  label: string;
+  sessions: T[];
+};
+
+export type GroupedSessions<T extends SessionListRow = SessionListRow> = {
+  /** Running sessions, pinned above every recency group, most-recent first. */
+  running: T[];
+  /** Non-running sessions bucketed by recency (empty buckets dropped). */
+  grouped: SessionRecencyBucket<T>[];
+};
+
+/**
+ * Order + bucket the sessions for the rail. Running sessions are lifted into a
+ * synthetic, always-first position regardless of recency (rendered with a
+ * "running" marker); the remainder are bucketed by recency, most-recent first
+ * within each bucket. Empty groups are dropped.
+ */
+export function groupSessionsForRail<T extends SessionListRow>(
+  sessions: T[],
+  now: Date = new Date(),
+): GroupedSessions<T> {
+  const running = sessions.filter(isEffectivelyRunning).sort(compareSessionActivity);
+  const rest = sessions
+    .filter((session) => !isEffectivelyRunning(session))
+    .sort(compareSessionActivity);
+
+  const buckets = new Map<SessionRecencyGroup, T[]>();
+  for (const session of rest) {
+    const group = recencyGroupFor(sessionActivityTime(session), now);
+    const list = buckets.get(group) ?? [];
+    list.push(session);
+    buckets.set(group, list);
+  }
+
+  const grouped: SessionRecencyBucket<T>[] = [];
+  for (const group of SESSION_GROUP_ORDER) {
+    const list = buckets.get(group);
+    if (list && list.length > 0) {
+      grouped.push({
+        group,
+        label: SESSION_GROUP_LABELS[group],
+        sessions: list,
+      });
+    }
+  }
+  return { running, grouped };
+}
+
+export function relativeTimeLabel(value: string, now: Date = new Date()): string {
+  const timestamp = Date.parse(value);
+  if (Number.isNaN(timestamp)) {
+    return "";
+  }
+  const diffSeconds = Math.max(0, Math.floor((now.getTime() - timestamp) / 1000));
+  if (diffSeconds < 45) {
+    return "now";
+  }
+  const minutes = Math.floor(diffSeconds / 60);
+  if (minutes < 60) {
+    return `${minutes}m`;
+  }
+  const hours = Math.floor(minutes / 60);
+  if (hours < 24) {
+    return `${hours}h`;
+  }
+  const days = Math.floor(hours / 24);
+  if (days < 7) {
+    return `${days}d`;
+  }
+  return new Date(timestamp).toLocaleDateString(undefined, {
+    month: "short",
+    day: "numeric",
+  });
+}
+
+/** Codex subscription product ids are prefixed `codex/`. */
+export function isCodexProductModel(modelId: string): boolean {
+  return modelId.startsWith("codex/");
+}
+
+export type SessionStatusTone = "queued" | "running" | "waiting" | "idle" | "failed" | "cancelled";
+
+export const SESSION_STATUS_TONE: Record<SessionStatus, SessionStatusTone> = {
+  queued: "queued",
+  running: "running",
+  recovering: "running",
+  waiting_capacity: "waiting",
+  requires_action: "waiting",
+  idle: "idle",
+  failed: "failed",
+  cancelled: "cancelled",
+};
+
+/** The status dot of a recent-session row: a background command reads as running. */
+export function recentSessionStatus(
+  session: Pick<SessionListRow, "status" | "backgroundCommandActivity">,
+): { tone: SessionStatusTone; pulse: boolean } {
+  const hasBackgroundCommand = session.backgroundCommandActivity !== undefined;
+  return {
+    tone: hasBackgroundCommand ? "running" : SESSION_STATUS_TONE[session.status],
+    pulse: hasBackgroundCommand || session.status === "running",
+  };
+}
+
+/** A short `owner/repo` label from the session's first repository resource. */
+export function sessionRepoLabel(session: Pick<Session, "resources">): string | null {
+  const repo = session.resources.find((resource) => resource.kind === "repository");
+  if (!repo || repo.kind !== "repository") {
+    return null;
+  }
+  const parts = repo.uri
+    .replace(/\.git$/, "")
+    .split("/")
+    .filter(Boolean);
+  return parts.length >= 2 ? parts.slice(-2).join("/") : (parts.at(-1) ?? null);
+}
+
+export function recentSessionModelPresentation<TCatalog extends ClientModel>(
+  modelId: string,
+  catalogRows: readonly PickerModelRow<TCatalog>[],
+): {
+  label: string;
+  billingClass: PickerModelRow["billingClass"];
+  logoUrl?: string | undefined;
+} {
+  const row = findPickerRow([...catalogRows], modelId);
+  return {
+    label: row?.label ?? modelDisplayName(modelId),
+    logoUrl: row?.catalog.logoUrl,
+    billingClass:
+      row?.billingClass ??
+      (isCodexProductModel(modelId) ? "codex_subscription" : "opengeni_credits"),
+  };
+}
+
+/**
+ * The home screen's recent sessions: server pins first, then running, then
+ * recency buckets, capped. `sessions` keeps the all-visible-row contract, so
+ * its pins are removed before recombining the explicit pinned section.
+ */
+export function recentSessionsForHome<T extends SessionListRow>(
+  sessions: T[],
+  pinned: T[],
+  limit = 6,
+  now: Date = new Date(),
+): T[] {
+  const ordinary = sessions.filter((session) => !session.pinned);
+  const { running, grouped } = groupSessionsForRail(ordinary, now);
+  return [...pinned, ...running, ...grouped.flatMap((bucket) => bucket.sessions)].slice(0, limit);
+}
+
+export { findPickerRow };

package/src/session-status-model.ts

@@ -0,0 +1,62 @@
+import type { SessionStatus } from "@opengeni/sdk";
+
+/** Status token family (`--og-color-status-<tone>`) for a session status. */
+export type SessionStatusTone = "queued" | "running" | "waiting" | "idle" | "failed" | "cancelled";
+
+/** Renderer-neutral session status presentation: label, color family and liveness. */
+export const SESSION_STATUS_PRESENTATION: Record<
+  SessionStatus,
+  { label: string; tone: SessionStatusTone; pulse: boolean }
+> = {
+  queued: { label: "Queued", tone: "queued", pulse: false },
+  running: { label: "Running", tone: "running", pulse: true },
+  recovering: { label: "Recovering", tone: "running", pulse: true },
+  waiting_capacity: { label: "Waiting for capacity", tone: "waiting", pulse: true },
+  idle: { label: "Idle", tone: "idle", pulse: false },
+  requires_action: { label: "Waiting on you", tone: "waiting", pulse: true },
+  failed: { label: "Failed", tone: "failed", pulse: false },
+  cancelled: { label: "Cancelled", tone: "cancelled", pulse: false },
+};
+
+/**
+ * The status badge's color tokens (text, border and its alpha); the fill is the
+ * status color at 10%. Mirrors the web badge classes, for non-DOM renderers.
+ */
+export const SESSION_STATUS_BADGE: Record<
+  SessionStatus,
+  { text: string; border: string; borderAlpha: number; fill: string }
+> = {
+  queued: { text: "fg-muted", border: "border", borderAlpha: 1, fill: "status-queued" },
+  running: {
+    text: "status-running",
+    border: "status-running",
+    borderAlpha: 0.3,
+    fill: "status-running",
+  },
+  recovering: {
+    text: "status-running",
+    border: "status-running",
+    borderAlpha: 0.3,
+    fill: "status-running",
+  },
+  waiting_capacity: {
+    text: "status-waiting",
+    border: "status-waiting",
+    borderAlpha: 0.35,
+    fill: "status-waiting",
+  },
+  idle: { text: "status-idle", border: "status-idle", borderAlpha: 0.3, fill: "status-idle" },
+  requires_action: {
+    text: "status-waiting",
+    border: "status-waiting",
+    borderAlpha: 0.35,
+    fill: "status-waiting",
+  },
+  failed: {
+    text: "status-failed",
+    border: "status-failed",
+    borderAlpha: 0.35,
+    fill: "status-failed",
+  },
+  cancelled: { text: "fg-subtle", border: "border", borderAlpha: 1, fill: "status-cancelled" },
+};