@opengeni/react 1.4.2 → 1.4.5-canary.37458084490001

package/src/hooks/use-goal.ts

@@ -1,5 +1,5 @@
 import { OpenGeniApiError, type SessionEvent, type SessionGoal } from "@opengeni/sdk";
-import { useCallback, useEffect, useRef, useState } from "react";
+import { useCallback, useEffect, useLayoutEffect, useRef, useState } from "react";
 import { useEmbeddedGoal, type EmbeddedGoalClientOverride } from "../session-context";
 import { normalizeError } from "../lib/error-message";
 import {
@@ -65,7 +65,8 @@ export type UseGoalResult = {
 /**
  * The session's goal: state, the autonomy counters (`autoContinuations`,
  * `noProgressStreak`), and pause/resume control. A goal-less session yields
- * `goal: null` (the 404 is absorbed). Live-updates on goal, turn, session,
+ * `goal: null`: read through `findGoal` as a successful null when the client
+ * has it, otherwise from an absorbed 404. Live-updates on goal, turn, session,
  * control, and system-update events — pass `options.events` from
  * `useSessionEvents` to reuse its stream.
  */
@@ -84,10 +85,19 @@ export function useGoal(
   const { run, mutating, mutationError, clearMutationError } = useMutationRunner();
   const generation = useRef(0);
   const targetKeyRef = useRef<string | null>(null);
-  // True after the server answered 404. Only a goal event can create a goal,
-  // so turn/session traffic must not refetch (and 404) while none exists.
+  // True after the server answered that no goal exists. Only a goal event can
+  // create a goal, so turn/session traffic must not refetch while none exists.
   const goalAbsentRef = useRef(false);
+  // Refresh events not yet covered by a read: "goal" when any was a goal.*
+  // event. Events that arrive while a read is in flight are decided when it
+  // settles, so the stream's opening burst never re-reads a goal-less session.
+  const pendingRefreshRef = useRef<"none" | "refresh" | "goal">("none");
+  const sharedEventsRef = useRef(sharedEvents);
+  useLayoutEffect(() => {
+    sharedEventsRef.current = sharedEvents;
+  }, [sharedEvents]);
   const loadAbort = useRef<AbortController | null>(null);
+  const scheduleRefreshRef = useRef<() => void>(() => undefined);
 
   const retireLoads = useCallback(() => {
     generation.current += 1;
@@ -100,15 +110,20 @@ export function useGoal(
       return;
     }
     const ticket = ++generation.current;
+    pendingRefreshRef.current = "none";
     loadAbort.current?.abort();
     const controller = new AbortController();
     loadAbort.current = controller;
     try {
-      const fetched = await client.getGoal(workspaceId, sessionId, {
-        signal: controller.signal,
-      });
+      // findGoal reads a goal-less session as a successful null, so no failed
+      // request reaches the browser console. Custom clients without it keep
+      // getGoal, whose 404 is absorbed below (as it is from older servers).
+      const fetched =
+        typeof client.findGoal === "function"
+          ? await client.findGoal(workspaceId, sessionId, { signal: controller.signal })
+          : await client.getGoal(workspaceId, sessionId, { signal: controller.signal });
       if (ticket === generation.current) {
-        goalAbsentRef.current = false;
+        goalAbsentRef.current = fetched === null;
         setGoal(fetched);
         setError(null);
         setLoading(false);
@@ -129,6 +144,26 @@ export function useGoal(
     } finally {
       if (loadAbort.current === controller) loadAbort.current = null;
     }
+    if (ticket !== generation.current || pendingRefreshRef.current === "none") {
+      return;
+    }
+    // Events arrived during this read. A shared feed's first batch reports only
+    // its latest match, so a goal.* event behind newer turn traffic is visible
+    // only in the log: re-read when its latest goal event is not a clear.
+    if (goalAbsentRef.current && pendingRefreshRef.current === "refresh") {
+      const events = sharedEventsRef.current ?? [];
+      let latestGoalEvent: SessionEvent | undefined;
+      for (let index = events.length - 1; index >= 0 && !latestGoalEvent; index -= 1) {
+        const event = events[index];
+        if (event && isGoalEvent(event)) latestGoalEvent = event;
+      }
+      if (!latestGoalEvent || latestGoalEvent.type === "goal.cleared") {
+        pendingRefreshRef.current = "none";
+        return;
+      }
+      pendingRefreshRef.current = "goal";
+    }
+    scheduleRefreshRef.current();
   }, [client, workspaceId, sessionId]);
 
   useEffect(() => {
@@ -136,6 +171,7 @@ export function useGoal(
     if (targetKeyRef.current !== targetKey) {
       targetKeyRef.current = targetKey;
       goalAbsentRef.current = false;
+      pendingRefreshRef.current = "none";
       setGoal(null);
       setError(null);
     }
@@ -186,13 +222,33 @@ export function useGoal(
     sharedFeed,
   ]);
 
-  const scheduleRefresh = useDebouncedCallback(() => void load());
+  const scheduleRefresh = useDebouncedCallback(() => {
+    const pending = pendingRefreshRef.current;
+    // An in-flight read settles pending events itself.
+    if (pending === "none" || loadAbort.current !== null) return;
+    if (pending === "refresh" && goalAbsentRef.current) {
+      pendingRefreshRef.current = "none";
+      return;
+    }
+    void load();
+  });
+  useLayoutEffect(() => {
+    scheduleRefreshRef.current = scheduleRefresh;
+  }, [scheduleRefresh]);
   const isRefreshEvent = useCallback(
     (event: SessionEvent) =>
       goalAbsentRef.current ? isGoalEvent(event) : isGoalRefreshEvent(event),
     [],
   );
-  useSessionEventTrigger(client, workspaceId, sessionId, isRefreshEvent, scheduleRefresh, {
+  const onRefreshEvent = useCallback(
+    (event: SessionEvent) => {
+      if (isGoalEvent(event)) pendingRefreshRef.current = "goal";
+      else if (pendingRefreshRef.current === "none") pendingRefreshRef.current = "refresh";
+      scheduleRefresh();
+    },
+    [scheduleRefresh],
+  );
+  useSessionEventTrigger(client, workspaceId, sessionId, isRefreshEvent, onRefreshEvent, {
     enabled,
     ...(sharedEvents !== undefined ? { events: sharedEvents } : {}),
   });

package/src/human-input-model.ts

@@ -0,0 +1,147 @@
+import type { HumanInputAnswer, HumanInputQuestion } from "@opengeni/sdk";
+
+/* Pure drafting and validation rules for structured human-input requests,
+   shared by the web HumanInputForm and non-DOM renderers. */
+
+export type HumanInputAnswerDraft = {
+  values: string[];
+  other: string;
+  otherSelected: boolean;
+};
+
+export type HumanInputFormMessages = {
+  title: string;
+  description: string;
+  submit: string;
+  skip: string;
+  submitting: string;
+  other: string;
+  deadlineLabel: string;
+  formatDeadline: (value: string) => string;
+  required: string;
+  otherRequired: string;
+  minSelections: (count: number) => string;
+  maxSelections: (count: number) => string;
+  optional: string;
+  /** Shown when the question list overflows the card and more content is below. */
+  moreBelow: string;
+  questionCount: (count: number) => string;
+  collapse: string;
+  expand: string;
+  selectionHint: (min: number | null | undefined, max: number | null | undefined) => string | null;
+};
+
+export const defaultHumanInputFormMessages: HumanInputFormMessages = {
+  title: "Input required",
+  /** Multi-question chrome has no default subtitle; hosts may still override. */
+  description: "",
+  submit: "Send answers",
+  skip: "Skip",
+  submitting: "Submitting…",
+  other: "Other",
+  deadlineLabel: "Expires",
+  formatDeadline,
+  required: "This question is required.",
+  otherRequired: "Enter a value for Other.",
+  minSelections: (count) => `Choose at least ${count} option${count === 1 ? "" : "s"}.`,
+  maxSelections: (count) => `Choose no more than ${count} option${count === 1 ? "" : "s"}.`,
+  optional: "Optional",
+  moreBelow: "More below",
+  questionCount: (count) => `${count} questions`,
+  collapse: "Collapse",
+  expand: "Expand",
+  selectionHint: (min, max) => {
+    if (min != null && max != null) return `Choose ${min}–${max}.`;
+    if (min != null) return `Choose at least ${min}.`;
+    if (max != null) return `Choose up to ${max}.`;
+    return null;
+  },
+};
+
+export function answersFromDrafts(
+  questions: HumanInputQuestion[],
+  drafts: Record<string, HumanInputAnswerDraft>,
+  messageOverrides: Partial<HumanInputFormMessages> = {},
+): { answers: HumanInputAnswer[]; errors: Record<string, string> } {
+  const messages = { ...defaultHumanInputFormMessages, ...messageOverrides };
+  const answers: HumanInputAnswer[] = [];
+  const errors: Record<string, string> = {};
+  for (const question of questions) {
+    const draft = drafts[question.id] ?? emptyDraft();
+    const values = question.kind === "text" ? draft.values.filter(Boolean) : draft.values;
+    const other = draft.otherSelected ? draft.other : "";
+    const hasOther = Boolean(other.trim());
+    const supplied = values.length + (hasOther ? 1 : 0);
+
+    // Other-selected-but-empty must win over generic "required" — otherwise the
+    // user sees the wrong diagnosis next to a clearly selected control.
+    if (question.kind !== "text" && draft.otherSelected && !hasOther) {
+      errors[question.id] = messages.otherRequired;
+      continue;
+    }
+
+    if (question.required && supplied === 0) {
+      errors[question.id] = messages.required;
+      continue;
+    }
+    if (question.kind !== "text") {
+      const min = question.validation?.minSelections;
+      const max = question.kind === "single_select" ? 1 : question.validation?.maxSelections;
+      if (min != null && supplied < min) {
+        errors[question.id] = messages.minSelections(min);
+        continue;
+      }
+      if (max != null && supplied > max) {
+        errors[question.id] = messages.maxSelections(max);
+        continue;
+      }
+    }
+    if (supplied > 0) {
+      answers.push({
+        questionId: question.id,
+        values,
+        ...(hasOther ? { other } : {}),
+      });
+    }
+  }
+  return { answers, errors };
+}
+
+export function initialDrafts(
+  questions: HumanInputQuestion[],
+): Record<string, HumanInputAnswerDraft> {
+  return Object.fromEntries(questions.map((question) => [question.id, emptyDraft()]));
+}
+
+export function emptyDraft(): HumanInputAnswerDraft {
+  return { values: [], other: "", otherSelected: false };
+}
+
+export function formatDeadline(value: string): string {
+  const date = new Date(value);
+  if (Number.isNaN(date.getTime())) return value;
+  const ms = date.getTime() - Date.now();
+  if (ms <= 0) return "deadline passed";
+  const minutes = Math.round(ms / 60_000);
+  if (minutes < 1) return "in under a minute";
+  if (minutes < 60) return `in ${minutes}m`;
+  const hours = Math.round(minutes / 60);
+  if (hours < 48) return `in ${hours}h`;
+  return date.toLocaleString();
+}
+
+/** The form heading: a single question leads with its own label/prompt. */
+export function humanInputHeading(
+  questions: readonly HumanInputQuestion[],
+  messages: Pick<HumanInputFormMessages, "title" | "description">,
+): { title: string; description: string | null } {
+  const single = questions.length === 1 ? questions[0]! : null;
+  return {
+    title: single ? (single.label ?? single.prompt) : messages.title,
+    description: single
+      ? single.label
+        ? single.prompt
+        : (single.helpText ?? null)
+      : messages.description || null,
+  };
+}

package/src/index.ts

@@ -401,6 +401,7 @@ export {
 export type {
   CreateToolRegistryOptions,
   RetainedArtifactLoader,
+  RetainedArtifactLoadOptions,
   RetainedArtifactLoaderClient,
   RetainedScreenshotLoader,
   RetainedScreenshotLoaderClient,
@@ -716,6 +717,20 @@ export {
   truncate,
   tryParseJson,
 } from "./lib/format";
+export {
+  currentProviderRecovery,
+  parseProviderRecovery,
+  providerRecoveryExhaustedText,
+  providerRecoveryRetryingText,
+  providerRecoverySubject,
+  type ProviderRecoveryCondition,
+  type ProviderRecoveryFacts,
+} from "./lib/provider-recovery";
+export {
+  ProviderRecoveryNotice,
+  PROVIDER_RECOVERY_NOTICE_DETAIL,
+  type ProviderRecoveryNoticeProps,
+} from "./components/provider-recovery-notice";
 export { SessionCommandsPanel } from "./components/session-commands-panel";
 export { SessionCommands } from "./components/session-commands";
 
@@ -728,6 +743,7 @@ export { setStartupDetails, useStartupDetails } from "./timeline/startup-prefere
 export { ClaudeMark } from "./components/claude-mark";
 export { AnthropicMark } from "./components/anthropic-mark";
 export { OpenRouterMark } from "./components/openrouter-mark";
+export { OpperMark } from "./components/opper-mark";
 export { GrokMark } from "./components/grok-mark";
 
 export { ToolReviewHistoryProvider } from "./components/tool-review-history";

package/src/lib/clipboard.ts

@@ -35,6 +35,35 @@ export async function copyTextToClipboard(text: string): Promise<boolean> {
   }
 }
 
+/**
+ * Copy text that is still being prepared, such as a command around a freshly
+ * minted URL. Safari only allows a clipboard write during the click itself, so
+ * hand the pending text to a `ClipboardItem` where supported; otherwise wait
+ * for it and copy. Resolves false when the text failed or nothing was copied.
+ */
+export async function copyPendingTextToClipboard(text: Promise<string>): Promise<boolean> {
+  if (
+    typeof ClipboardItem !== "undefined" &&
+    typeof navigator !== "undefined" &&
+    typeof navigator.clipboard?.write === "function"
+  ) {
+    const blob = text.then((value) => new Blob([value], { type: "text/plain" }));
+    // The caller observes a failed `text`; never leave this copy unhandled.
+    blob.catch(() => {});
+    try {
+      await navigator.clipboard.write([new ClipboardItem({ "text/plain": blob })]);
+      return true;
+    } catch {
+      // Fall through: some browsers reject promised clipboard items.
+    }
+  }
+  try {
+    return await copyTextToClipboard(await text);
+  } catch {
+    return false;
+  }
+}
+
 /** Serialize an HTML table to tab-separated values (spreadsheet-friendly). */
 export function tableElementToTsv(table: HTMLTableElement | null | undefined): string {
   if (!table) {

package/src/lib/format.ts

@@ -1,4 +1,5 @@
 import { formatErrorMessage, OpenGeniApiError } from "@opengeni/sdk";
+import { parseProviderRecovery, providerRecoveryExhaustedText } from "./provider-recovery";
 
 const clockTimeFormatter = new Intl.DateTimeFormat(undefined, {
   month: "short",
@@ -312,6 +313,12 @@ export function presentFailure(payload: Record<string, unknown>): {
       safetyRefusal: true,
     };
   }
+  // Spent automatic retries: name the model and the remedy instead of the
+  // recorded wrapper plus raw provider text (still in the stored event).
+  const recovery = parseProviderRecovery(payload);
+  if (recovery && payload.recoveryExhausted === true) {
+    return { reason: providerRecoveryExhaustedText(recovery), safetyRefusal: false };
+  }
   return {
     reason:
       detail && detail !== message

package/src/lib/provider-recovery.ts

@@ -0,0 +1,202 @@
+import type { SessionEvent, SessionStatus } from "@opengeni/sdk";
+
+/**
+ * Finite same-turn provider recovery, projected for people. Presentation only:
+ * the worker owns retry authority, pacing and the recovery budget. The worker
+ * (`apps/worker/src/activities/agent-turn/provider-recovery-copy.ts`) writes
+ * the same exhausted sentence into `turn.failed.error`; keep the two in step.
+ */
+export type ProviderRecoveryCondition =
+  | "overloaded"
+  | "unavailable"
+  | "unresponsive"
+  | "rate_limited";
+
+export type ProviderRecoveryFacts = {
+  /** Recorded worker failure code (`provider_unavailable`, `mcp_transport_timeout`, ...). */
+  code: string;
+  condition: ProviderRecoveryCondition | null;
+  /** Display label of the affected model, when the route was recorded. */
+  modelLabel: string | null;
+  /** Display label of the serving provider, when the route was recorded. */
+  providerLabel: string | null;
+  /** Automatic retries scheduled (live) or spent (exhausted). */
+  attempt: number | null;
+  /** Finite automatic retry budget. */
+  maxAttempts: number | null;
+  /** True when the model route itself is affected, so another model may help. */
+  modelRoute: boolean;
+};
+
+const MODEL_CODES: ReadonlySet<string> = new Set([
+  "provider_unavailable",
+  "provider_rate_limited",
+  "provider_unknown_finish_reason",
+  "post_compaction_continuation_empty",
+]);
+
+const RECOVERY_CODES: ReadonlySet<string> = new Set([
+  ...MODEL_CODES,
+  "upstream_connectivity_unavailable",
+  "mcp_transport_timeout",
+  "mcp_transport_unavailable",
+  "sandbox_command_start_unavailable",
+  "turn_execution_policy_definition_mismatch",
+]);
+
+/** Matches the worker's default budget for legacy events that omit it. */
+const DEFAULT_MAX_ATTEMPTS = 5;
+
+function text(value: unknown, max = 120): string | null {
+  if (typeof value !== "string") return null;
+  const normalized = value.replace(/\s+/g, " ").trim();
+  return normalized ? normalized.slice(0, max) : null;
+}
+
+function count(value: unknown): number | null {
+  return typeof value === "number" && Number.isSafeInteger(value) && value > 0 ? value : null;
+}
+
+function condition(
+  payload: Record<string, unknown>,
+  code: string,
+): ProviderRecoveryCondition | null {
+  const recorded = payload.providerCondition;
+  if (
+    recorded === "overloaded" ||
+    recorded === "unavailable" ||
+    recorded === "unresponsive" ||
+    recorded === "rate_limited"
+  )
+    return recorded;
+  if (code === "provider_rate_limited") return "rate_limited";
+  if (code !== "provider_unavailable") return null;
+  // Older events predate the typed condition; their provider text still says so.
+  return [payload.lastRetryableError, payload.detail, payload.error].some(
+    (value) => typeof value === "string" && /\boverload(?:ed)?(?:_error)?\b/i.test(value),
+  )
+    ? "overloaded"
+    : null;
+}
+
+/**
+ * Read a retryable `turn.recovery.requested` payload or an exhausted
+ * `turn.failed` payload. Returns null for every other recovery reason (human
+ * Retry, worker shutdown, credential rotation, capacity waits, ...).
+ */
+export function parseProviderRecovery(payload: unknown): ProviderRecoveryFacts | null {
+  if (!payload || typeof payload !== "object" || Array.isArray(payload)) return null;
+  const record = payload as Record<string, unknown>;
+  const code = text(record.code) ?? text(record.reason);
+  if (!code || !RECOVERY_CODES.has(code)) return null;
+  // A live recovery request is retryable; a spent budget is explicitly marked.
+  if (record.recoveryExhausted !== true && record.retryable === false) return null;
+  const attempt = count(record.providerRecoveryCount);
+  return {
+    code,
+    condition: condition(record, code),
+    modelLabel: text(record.modelLabel),
+    providerLabel: text(record.providerLabel),
+    attempt,
+    maxAttempts: count(record.maxProviderRecoveryCount) ?? DEFAULT_MAX_ATTEMPTS,
+    modelRoute: MODEL_CODES.has(code),
+  };
+}
+
+/** One present-tense clause naming what is unavailable, without a trailing period. */
+export function providerRecoverySubject(facts: ProviderRecoveryFacts): string {
+  const model = facts.modelLabel ?? "The model";
+  const at = facts.providerLabel ? ` at the provider (${facts.providerLabel})` : " at the provider";
+  switch (facts.code) {
+    case "provider_rate_limited":
+      return `${model} is rate limited${at}`;
+    case "provider_unavailable":
+      return facts.condition === "overloaded"
+        ? `${model} is overloaded${at}`
+        : facts.condition === "unresponsive"
+          ? `${model} stopped responding${at}`
+          : `${model} is temporarily unavailable${at}`;
+    case "provider_unknown_finish_reason":
+      return `${model} ended its response unexpectedly`;
+    case "post_compaction_continuation_empty":
+      return `${model} stopped right after compacting the conversation`;
+    case "upstream_connectivity_unavailable":
+      return "Opengeni can't reach an upstream service";
+    case "mcp_transport_timeout":
+      return "A required MCP server isn't responding";
+    case "mcp_transport_unavailable":
+      return "A required MCP server is unreachable";
+    case "sandbox_command_start_unavailable":
+      return "The sandbox isn't ready yet";
+    case "turn_execution_policy_definition_mismatch":
+      return "Opengeni is applying a configuration update";
+    default:
+      return "A service this turn depends on is temporarily unavailable";
+  }
+}
+
+/** Live status while the same turn waits for its next automatic retry. */
+export function providerRecoveryRetryingText(facts: ProviderRecoveryFacts): string {
+  const progress =
+    facts.attempt !== null && facts.maxAttempts !== null
+      ? ` (attempt ${Math.min(facts.attempt, facts.maxAttempts)} of ${facts.maxAttempts})`
+      : " automatically";
+  return `${providerRecoverySubject(facts)} — retrying${progress}…`;
+}
+
+/** Terminal sentence once the automatic budget is spent. */
+export function providerRecoveryExhaustedText(facts: ProviderRecoveryFacts): string {
+  const spent = facts.attempt ?? facts.maxAttempts ?? DEFAULT_MAX_ATTEMPTS;
+  const retried = `Opengeni retried ${spent} ${spent === 1 ? "time" : "times"} without success.`;
+  const remedy = facts.modelRoute
+    ? "Try again in a few minutes, or switch to another model."
+    : "Try again in a few minutes.";
+  return `${providerRecoverySubject(facts)}. ${retried} ${remedy}`;
+}
+
+const BOUNDARY_TYPES: ReadonlySet<string> = new Set([
+  "turn.recovery.requested",
+  "turn.started",
+  "turn.completed",
+  "turn.failed",
+  "turn.cancelled",
+  "turn.superseded",
+]);
+
+/**
+ * The active turn's current automatic provider retry, or null. Only a
+ * `recovering`, unpaused session qualifies, and only the newest boundary of its
+ * exact active turn counts, so merged or replayed pages never borrow another
+ * turn's diagnosis.
+ */
+export function currentProviderRecovery(
+  session: {
+    id: string;
+    status: SessionStatus | null | undefined;
+    activeTurnId: string | null | undefined;
+    effectiveControl?: { state: string } | null | undefined;
+  },
+  events: readonly SessionEvent[],
+): ProviderRecoveryFacts | null {
+  if (
+    session.status !== "recovering" ||
+    (session.effectiveControl && session.effectiveControl.state !== "active") ||
+    !session.activeTurnId
+  )
+    return null;
+  let latest: SessionEvent | undefined;
+  for (const event of events) {
+    if (
+      event.sessionId !== session.id ||
+      event.turnId !== session.activeTurnId ||
+      event.duplicateOfEventId ||
+      (event.turnAssociation && event.turnAssociation !== "current") ||
+      !BOUNDARY_TYPES.has(event.type)
+    )
+      continue;
+    if (!latest || event.sequence > latest.sequence) latest = event;
+  }
+  if (latest?.type !== "turn.recovery.requested") return null;
+  const payload = latest.payload as Record<string, unknown> | null | undefined;
+  return payload?.recoveryExhausted === true ? null : parseProviderRecovery(payload);
+}

package/src/model-mark-paths.ts

@@ -0,0 +1,53 @@
+// Model maker marks as plain path data (24×24 viewBox, filled with the current
+// color), shared by the web SVG components and native renderers so both draw
+// identical geometry.
+import { modelVendor, type ModelDisplayInput, type ModelVendor } from "@opengeni/sdk/model-display";
+
+/** ChatGPT / OpenAI mark (Simple Icons, CC0). */
+export const CHATGPT_MARK_PATH =
+  "M22.2819 9.8211a5.9847 5.9847 0 0 0-.5157-4.9108 6.0462 6.0462 0 0 0-6.5098-2.9A6.0651 6.0651 0 0 0 4.9807 4.1818a5.9847 5.9847 0 0 0-3.9977 2.9 6.0462 6.0462 0 0 0 .7427 7.0966 5.98 5.98 0 0 0 .511 4.9107 6.051 6.051 0 0 0 6.5146 2.9001A5.9847 5.9847 0 0 0 13.2599 24a6.0557 6.0557 0 0 0 5.7718-4.2058 5.9894 5.9894 0 0 0 3.9977-2.9001 6.0557 6.0557 0 0 0-.7475-7.0729zm-9.022 12.6081a4.4755 4.4755 0 0 1-2.8764-1.0408l.1419-.0804 4.7783-2.7582a.7948.7948 0 0 0 .3927-.6813v-6.7369l2.02 1.1686a.071.071 0 0 1 .038.052v5.5826a4.504 4.504 0 0 1-4.4945 4.4944zm-9.6607-4.1254a4.4708 4.4708 0 0 1-.5346-3.0137l.142.0852 4.783 2.7582a.7712.7712 0 0 0 .7806 0l5.8428-3.3685v2.3324a.0804.0804 0 0 1-.0332.0615L9.74 19.9502a4.4992 4.4992 0 0 1-6.1408-1.6464zM2.3408 7.8956a4.485 4.485 0 0 1 2.3653-1.9728V11.6a.7664.7664 0 0 0 .3879.6765l5.8414 3.3698-2.02 1.1685a.0757.0757 0 0 1-.071 0l-4.8303-2.7865A4.504 4.504 0 0 1 2.3408 7.872zm16.5963 3.8558L13.1038 8.364 15.1192 7.2a.0757.0757 0 0 1 .071 0l4.8303 2.7913a4.4944 4.4944 0 0 1-.6765 8.1042v-5.6772a.79.79 0 0 0-.407-.667zm2.0107-3.0231l-.142-.0852-4.783-2.7622a.7759.7759 0 0 0-.7854 0L9.409 9.2297V6.8974a.0662.0662 0 0 1 .0284-.0615l4.8303-2.7866a4.4992 4.4992 0 0 1 6.6802 4.66zM8.3065 12.863l-2.02-1.1638a.0804.0804 0 0 1-.038-.0567V6.0742a4.4992 4.4992 0 0 1 7.3757-3.4537l-.142.0805L8.704 5.459a.7948.7948 0 0 0-.3927.6813zm1.0976-2.3654l2.602-1.4998 2.6069 1.4998v2.9994l-2.5974 1.4997-2.6067-1.4997Z";
+
+/** Claude mark (Simple Icons, CC0; https://github.com/simple-icons/simple-icons). */
+export const CLAUDE_MARK_PATH =
+  "m4.7144 15.9555 4.7174-2.6471.079-.2307-.079-.1275h-.2307l-.7893-.0486-2.6956-.0729-2.3375-.0971-2.2646-.1214-.5707-.1215-.5343-.7042.0546-.3522.4797-.3218.686.0608 1.5179.1032 2.2767.1578 1.6514.0972 2.4468.255h.3886l.0546-.1579-.1336-.0971-.1032-.0972L6.973 9.8356l-2.55-1.6879-1.3356-.9714-.7225-.4918-.3643-.4614-.1578-1.0078.6557-.7225.8803.0607.2246.0607.8925.686 1.9064 1.4754 2.4893 1.8336.3643.3035.1457-.1032.0182-.0728-.164-.2733-1.3539-2.4467-1.445-2.4893-.6435-1.032-.17-.6194c-.0607-.255-.1032-.4674-.1032-.7285L6.287.1335 6.6997 0l.9957.1336.419.3642.6192 1.4147 1.0018 2.2282 1.5543 3.0296.4553.8985.2429.8318.091.255h.1579v-.1457l.1275-1.706.2368-2.0947.2307-2.6957.0789-.7589.3764-.9107.7468-.4918.5828.2793.4797.686-.0668.4433-.2853 1.8517-.5586 2.9021-.3643 1.9429h.2125l.2429-.2429.9835-1.3053 1.6514-2.0643.7286-.8196.85-.9046.5464-.4311h1.0321l.759 1.1293-.34 1.1657-1.0625 1.3478-.8804 1.1414-1.2628 1.7-.7893 1.36.0729.1093.1882-.0183 2.8535-.607 1.5421-.2794 1.8396-.3157.8318.3886.091.3946-.3278.8075-1.967.4857-2.3072.4614-3.4364.8136-.0425.0304.0486.0607 1.5482.1457.6618.0364h1.621l3.0175.2247.7892.522.4736.6376-.079.4857-1.2142.6193-1.6393-.3886-3.825-.9107-1.3113-.3279h-.1822v.1093l1.0929 1.0686 2.0035 1.8092 2.5075 2.3314.1275.5768-.3218.4554-.34-.0486-2.2039-1.6575-.85-.7468-1.9246-1.621h-.1275v.17l.4432.6496 2.3436 3.5214.1214 1.0807-.17.3521-.6071.2125-.6679-.1214-1.3721-1.9246L14.38 17.959l-1.1414-1.9428-.1397.079-.674 7.2552-.3156.3703-.7286.2793-.6071-.4614-.3218-.7468.3218-1.4753.3886-1.9246.3157-1.53.2853-1.9004.17-.6314-.0121-.0425-.1397.0182-1.4328 1.9672-2.1796 2.9446-1.7243 1.8456-.4128.164-.7164-.3704.0667-.6618.4008-.5889 2.386-3.0357 1.4389-1.882.929-1.0868-.0062-.1579h-.0546l-6.3385 4.1164-1.1293.1457-.4857-.4554.0608-.7467.2307-.2429 1.9064-1.3114Z";
+
+/**
+ * MIT License
+ *
+ * Copyright (c) 2023 LobeHub
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ * Source: https://raw.githubusercontent.com/lobehub/lobe-icons/master/src/Grok/components/Mono.tsx
+ */
+export const GROK_MARK_PATH =
+  "M9.27 15.29l7.978-5.897c.391-.29.95-.177 1.137.272.98 2.369.542 5.215-1.41 7.169-1.951 1.954-4.667 2.382-7.149 1.406l-2.711 1.257c3.889 2.661 8.611 2.003 11.562-.953 2.341-2.344 3.066-5.539 2.388-8.42l.006.007c-.983-4.232.242-5.924 2.75-9.383.06-.082.12-.164.179-.248l-3.301 3.305v-.01L9.267 15.292M7.623 16.723c-2.792-2.67-2.31-6.801.071-9.184 1.761-1.763 4.647-2.483 7.166-1.425l2.705-1.25a7.808 7.808 0 00-1.829-1A8.975 8.975 0 005.984 5.83c-2.533 2.536-3.33 6.436-1.962 9.764 1.022 2.487-.653 4.246-2.34 6.022-.599.63-1.199 1.259-1.682 1.925l7.62-6.815";
+
+export type MarkedModelVendor = Extract<ModelVendor, "openai" | "anthropic" | "xai">;
+
+export const MODEL_MARK_PATHS: Record<MarkedModelVendor, string> = {
+  openai: CHATGPT_MARK_PATH,
+  anthropic: CLAUDE_MARK_PATH,
+  xai: GROK_MARK_PATH,
+};
+
+/** The maker whose logo marks this model, or null for the neutral fallback. */
+export function modelMarkVendor(model: ModelDisplayInput): MarkedModelVendor | null {
+  const vendor = modelVendor(model);
+  return vendor === "openai" || vendor === "anthropic" || vendor === "xai" ? vendor : null;
+}