@oar-sh/oar 0.9.0

package/server/public/app/conversation-preferences.mjs

@@ -0,0 +1,91 @@
+const DEFAULT_FALLBACK_MODE = 'agent';
+
+// Stored preferences arrive as '' when unset, so `??` would treat them as real
+// values and block every fallback behind them.
+export function normalizePreferenceValue(value) {
+  return String(value ?? '').trim();
+}
+
+export function firstDefinedPreference(...values) {
+  for (const value of values) {
+    const normalized = normalizePreferenceValue(value);
+    if (normalized) return normalized;
+  }
+  return '';
+}
+
+function normalizeModeList(modes = []) {
+  return Array.isArray(modes)
+    ? modes.map((mode) => String(mode || '').trim()).filter(Boolean)
+    : [];
+}
+
+function normalizeModelList(models = []) {
+  return Array.isArray(models)
+    ? models.map((model) => String(model || '').trim()).filter(Boolean)
+    : [];
+}
+
+export function resolveConversationComposerSelection({
+  preferredRelayMode = '',
+  preferredModel = '',
+  selectedMode = '',
+  selectedModel = '',
+  supportedModes = [],
+  supportedModels = [],
+  fallbackMode = DEFAULT_FALLBACK_MODE,
+  fallbackModel = '',
+} = {}) {
+  const allowedModes = normalizeModeList(supportedModes);
+  const allowedModels = normalizeModelList(supportedModels);
+  const modeFallback = allowedModes.includes(fallbackMode)
+    ? fallbackMode
+    : (allowedModes[0] || DEFAULT_FALLBACK_MODE);
+  const preferredMode = String(preferredRelayMode || '').trim();
+  const nextMode = allowedModes.includes(preferredMode)
+    ? preferredMode
+    : (allowedModes.includes(String(selectedMode || '').trim())
+      ? String(selectedMode || '').trim()
+      : modeFallback);
+
+  const modelCandidates = [
+    String(preferredModel || '').trim(),
+    String(selectedModel || '').trim(),
+    String(fallbackModel || '').trim(),
+    allowedModels[0] || '',
+  ].filter(Boolean);
+  // Provider catalogs own their casing, so a stored id that only differs in
+  // case still resolves to the catalog entry instead of dropping to a fallback.
+  const matchAllowedModel = (candidate) => allowedModels.find(
+    (allowed) => allowed === candidate || allowed.toLowerCase() === candidate.toLowerCase(),
+  );
+  const nextModel = allowedModels.length
+    ? (modelCandidates.map(matchAllowedModel).find(Boolean) || allowedModels[0])
+    : (modelCandidates[0] || '');
+
+  return {
+    mode: nextMode,
+    model: nextModel,
+  };
+}
+
+// Priority: an explicit request (conversation preference, or the effort being
+// carried across a user model change) beats what the previous conversation left
+// in the DOM. Reversing those two is what let a New Chat "high" become "low".
+export function resolveComposerReasoningEffort({
+  preferredEffort = '',
+  storedEffort = '',
+  currentEffort = '',
+  supportedEfforts = [],
+} = {}) {
+  const options = (Array.isArray(supportedEfforts) ? supportedEfforts : [])
+    .map((effort) => String(effort || '').trim().toLowerCase())
+    .filter(Boolean);
+  if (!options.length) return '';
+  const candidates = [preferredEffort, storedEffort, currentEffort]
+    .map((effort) => String(effort || '').trim().toLowerCase())
+    .filter(Boolean);
+  const match = candidates.find((candidate) => options.includes(candidate));
+  if (match) return match;
+  return options.find((option) => option !== 'none') || options[0];
+}

package/server/public/app/conversation-provider-indicator.mjs

@@ -0,0 +1,88 @@
+export function resolveConversationProviderType(conversation = null) {
+  const providerType = String(
+    conversation?.runtimeProviderType
+    ?? conversation?.runtime_provider_type
+    ?? '',
+  ).trim().toLowerCase();
+  return providerType;
+}
+
+export function isConversationUsingOpenAIProvider(conversation = null) {
+  return resolveConversationProviderType(conversation) === 'openai';
+}
+
+export function isConversationUsingClaudeProvider(conversation = null) {
+  return resolveConversationProviderType(conversation) === 'claude';
+}
+
+export function isConversationUsingCursorProvider(conversation = null) {
+  return resolveConversationProviderType(conversation) === 'cursor';
+}
+
+export function isConversationUsingGrokProvider(conversation = null) {
+  return resolveConversationProviderType(conversation) === 'grok';
+}
+
+// An unresolved provider stays unlabelled rather than defaulting to Copilot, so
+// a conversation the client has not loaded yet cannot claim the wrong provider.
+export function conversationProviderIndicatorLabel(conversation = null) {
+  const providerType = resolveConversationProviderType(conversation);
+  if (providerType === 'openai') return 'OpenAI';
+  if (providerType === 'claude') return 'Claude';
+  if (providerType === 'cursor') return 'Cursor';
+  if (providerType === 'grok') return 'Grok';
+  if (providerType === 'github' || providerType === 'github-copilot') return 'Copilot';
+  return '';
+}
+
+const SESSION_LOCK_LABELS = {
+  github: 'GitHub Copilot',
+  openai: 'OpenAI',
+  'openai-image': 'OpenAI Image',
+  claude: 'Claude SDK',
+  cursor: 'Cursor SDK',
+  grok: 'Grok',
+};
+
+export function isOpenAIImageModelId(modelId = '') {
+  const normalized = String(modelId || '').trim().toLowerCase().replace(/^openai\//, '');
+  return normalized.startsWith('gpt-image-') || normalized.startsWith('dall-e-');
+}
+
+// Image conversations are stored as the `openai` provider with an image model,
+// so the image variant only exists as a derived label.
+export function sessionLockProviderKey({ providerType = '', model = '' } = {}) {
+  const normalized = String(providerType || '').trim().toLowerCase();
+  if (normalized === 'openai' || normalized === 'openai-byok') {
+    return isOpenAIImageModelId(model) ? 'openai-image' : 'openai';
+  }
+  if (normalized === 'openai-image' || normalized === 'openai-image-byok') return 'openai-image';
+  if (normalized === 'claude' || normalized === 'claude-agent-sdk' || normalized === 'anthropic') return 'claude';
+  if (normalized === 'cursor') return 'cursor';
+  if (normalized === 'grok' || normalized === 'xai' || normalized === 'xai-grok') return 'grok';
+  if (normalized === 'github' || normalized === 'github-copilot') return 'github';
+  return '';
+}
+
+export function sessionLockProviderLabel({ providerType = '', model = '' } = {}) {
+  return SESSION_LOCK_LABELS[sessionLockProviderKey({ providerType, model })] || '';
+}
+
+// The list pill borrows the composer's provider palette, so it resolves the same
+// key the session-lock note uses — including the derived OpenAI image variant.
+export function conversationProviderIndicatorKey(conversation = null) {
+  return sessionLockProviderKey({
+    providerType: resolveConversationProviderType(conversation),
+    model: conversation?.runtimeProviderModel
+      || conversation?.runtimeModel
+      || conversation?.preferredModel
+      || '',
+  });
+}
+
+export function sessionLockNoteText({ providerType = '', model = '', pinnedModel = '' } = {}) {
+  const label = sessionLockProviderLabel({ providerType, model });
+  if (!label) return '';
+  const pinned = String(pinnedModel || '').trim();
+  return `🔒 Session locked to ${label} models${pinned ? ` (${pinned})` : ''}.`;
+}