@oar-sh/oar 0.9.0

package/server/services/provider-model-selection.mjs

@@ -0,0 +1,91 @@
+'use strict';
+
+// Managed providers (OpenAI, Claude, Cursor, Grok) own their own model
+// catalogs: the Copilot catalog does not know these ids, so an explicit
+// selection must be resolved against the provider list alone. Resolving it
+// through the shared catalog first is what let a Cursor request fall back to
+// the global current model (e.g. "claude-opus-5") whenever the requested id
+// was missing from that catalog.
+
+export const AUTO_MODEL_SENTINEL = 'auto';
+
+export function normalizeProviderModelId(value) {
+  return String(value || '').trim();
+}
+
+export function isAutoModelId(value) {
+  return normalizeProviderModelId(value).toLowerCase() === AUTO_MODEL_SENTINEL;
+}
+
+// Availability lists are assembled from settings and discovery, which preserve
+// the provider's casing. Matching is case-insensitive, but the canonical entry
+// is what gets bound and persisted so every later comparison lines up.
+// Callers hold their catalogs as arrays or as Sets built for the older
+// case-sensitive checks, so both are accepted.
+function toModelList(availableModels) {
+  if (Array.isArray(availableModels)) return availableModels;
+  if (availableModels && typeof availableModels[Symbol.iterator] === 'function') return Array.from(availableModels);
+  return [];
+}
+
+export function buildCanonicalModelIndex(availableModels = []) {
+  const index = new Map();
+  for (const value of toModelList(availableModels)) {
+    const canonical = normalizeProviderModelId(value);
+    if (!canonical) continue;
+    const key = canonical.toLowerCase();
+    if (!index.has(key)) index.set(key, canonical);
+  }
+  return index;
+}
+
+export function canonicalProviderModelId(requestedModel, availableModels = []) {
+  const requested = normalizeProviderModelId(requestedModel);
+  if (!requested) return '';
+  return buildCanonicalModelIndex(availableModels).get(requested.toLowerCase()) || '';
+}
+
+export function isProviderModelAvailable(requestedModel, availableModels = []) {
+  return canonicalProviderModelId(requestedModel, availableModels) !== '';
+}
+
+// Resolution outcomes:
+//   matched  — the request named an available model (canonical casing returned)
+//   default  — no model was requested (blank or "auto"), so the provider default applies
+//   ok:false — the request named a model this provider does not offer; callers reject
+export function resolveProviderModelSelection({
+  requestedModel = '',
+  availableModels = [],
+  configuredModel = '',
+} = {}) {
+  const requested = normalizeProviderModelId(requestedModel);
+  const configured = normalizeProviderModelId(configuredModel);
+  const index = buildCanonicalModelIndex([configured, ...toModelList(availableModels)]);
+
+  if (!requested || isAutoModelId(requested)) {
+    return {
+      ok: true,
+      model: configured,
+      requestedModel: requested,
+      source: 'default',
+    };
+  }
+
+  const canonical = index.get(requested.toLowerCase());
+  if (canonical) {
+    return {
+      ok: true,
+      model: canonical,
+      requestedModel: requested,
+      source: 'matched',
+    };
+  }
+
+  return {
+    ok: false,
+    model: '',
+    requestedModel: requested,
+    source: 'unavailable',
+    availableModels: Array.from(index.values()),
+  };
+}

package/server/services/provider-reasoning-effort.mjs

@@ -0,0 +1,94 @@
+'use strict';
+
+import { openAIReasoningEffortsForModel } from '../../shared/openai-reasoning.mjs';
+
+// 'ultracode' is not an Agent SDK EffortLevel: it is a relay-side sentinel for
+// the SDK's session-scoped `ultracode` settings flag (xhigh effort plus
+// standing workflow orchestration). It rides the effort ladder end to end —
+// selector option, queue column, message field — and only the Claude worker
+// translates it into `effort: 'xhigh'` + `settings: { ultracode: true }`.
+// It must never be sent as an `effort`/`effortLevel` value: the CLI's schema
+// silently discards unknown levels.
+export const CLAUDE_ULTRACODE_EFFORT = 'ultracode';
+export const DEFAULT_CLAUDE_REASONING_EFFORTS = Object.freeze(['none', 'low', 'medium', 'high', 'xhigh', 'max', CLAUDE_ULTRACODE_EFFORT]);
+export const DEFAULT_GROK_REASONING_EFFORTS = Object.freeze(['none', 'low', 'medium', 'high']);
+
+// Ultracode requires an xhigh-capable model (the SDK's stated gate), so the
+// tier is derived from a model's discovered efforts rather than discovery —
+// `supportedModels()` never reports it. Idempotent: augmenting an
+// already-augmented ladder is a no-op.
+export function withClaudeUltracodeTier(efforts) {
+  const levels = (Array.isArray(efforts) ? efforts : []).map(normalizeEffort).filter(Boolean);
+  if (!levels.includes('xhigh') || levels.includes(CLAUDE_ULTRACODE_EFFORT)) return levels;
+  return [...levels, CLAUDE_ULTRACODE_EFFORT];
+}
+
+function normalizeEffort(value) {
+  return String(value || '').trim().toLowerCase();
+}
+
+function effortsForModel(effortsByModel, model) {
+  const key = normalizeEffort(model);
+  if (!key || !effortsByModel || typeof effortsByModel !== 'object') return null;
+  const efforts = effortsByModel[key];
+  return Array.isArray(efforts) ? efforts.map(normalizeEffort).filter(Boolean) : null;
+}
+
+// Returns the tiers a provider/model pair accepts, or null when the tiers are
+// unknown. null is not "no reasoning": Cursor models that predate effort
+// discovery must pass the request through so the worker can validate it against
+// the live model params instead of the relay silently disabling thinking.
+export function supportedReasoningEffortsForProviderModel({
+  providerType = '',
+  model = '',
+  cursorSettings = null,
+  claudeSettings = null,
+  grokSettings = null,
+  reasoningByModel = null,
+} = {}) {
+  const provider = normalizeEffort(providerType);
+  if (provider === 'cursor') return effortsForModel(cursorSettings?.effortsByModel, model);
+  if (provider === 'claude') {
+    return effortsForModel(claudeSettings?.effortsByModel, model) || [...DEFAULT_CLAUDE_REASONING_EFFORTS];
+  }
+  if (provider === 'grok') {
+    return effortsForModel(grokSettings?.effortsByModel, model) || [...DEFAULT_GROK_REASONING_EFFORTS];
+  }
+  if (provider === 'openai' || provider === 'openai-image') {
+    const efforts = openAIReasoningEffortsForModel(model);
+    return Array.isArray(efforts) && efforts.length ? efforts.map(normalizeEffort).filter(Boolean) : null;
+  }
+  return effortsForModel(reasoningByModel, model);
+}
+
+// Mirrors the per-turn rules on the message path so a New Chat selection and
+// the first send agree: a supported tier is kept, an unsupported one clamps to
+// the provider's off-switch, an unstated one takes the provider default, and an
+// unknown tier list passes through.
+//
+// `strict` reproduces the one provider that refuses rather than clamps: OpenAI
+// answers an unsupported effort with a 400, so bootstrap must not store a value
+// the first send would reject.
+export function resolveProviderReasoningEffort({
+  requestedEffort = '',
+  supportedEfforts = null,
+  strict = false,
+} = {}) {
+  const requested = normalizeEffort(requestedEffort);
+  const supported = Array.isArray(supportedEfforts)
+    ? supportedEfforts.map(normalizeEffort).filter(Boolean)
+    : null;
+  if (!supported) return { ok: true, effort: requested, supported: [] };
+  const providerDefault = supported.includes('none') ? 'none' : (supported[0] || '');
+  if (!requested) return { ok: true, effort: providerDefault, supported };
+  if (supported.includes(requested)) return { ok: true, effort: requested, supported };
+  if (strict) {
+    return {
+      ok: false,
+      effort: '',
+      supported,
+      error: `Reasoning effort "${requested}" is not supported`,
+    };
+  }
+  return { ok: true, effort: providerDefault, supported };
+}

package/server/services/push-active-device-service.mjs

@@ -0,0 +1,57 @@
+'use strict';
+
+/**
+ * Active-device tracking for push suppression.
+ *
+ * "Active" means: a connected socket whose client explicitly reported itself
+ * visible via a `device_visibility` heartbeat within the staleness window. A
+ * connected socket alone is not enough — the client keeps its transport open
+ * for a grace period after backgrounding, so a pocketed phone can hold a live
+ * socket for tens of seconds.
+ */
+
+export const DEVICE_VISIBILITY_STALE_MS = 90_000;
+
+/**
+ * @param {object} options
+ * @param {() => Iterable<import('socket.io').Socket>} options.getSockets connected sockets of the main namespace
+ * @param {number} [options.staleMs]
+ * @param {() => number} [options.now]
+ */
+export function createActiveDeviceTracker({ getSockets, staleMs = DEVICE_VISIBILITY_STALE_MS, now = () => Date.now() }) {
+  /**
+   * Bind visibility tracking to a freshly connected socket. Call from the
+   * io `connection` handler.
+   */
+  function registerSocket(socket) {
+    if (!socket) return;
+    if (socket.recovered === true && socket.data) {
+      // connectionStateRecovery restores socket.data from the recovered
+      // session, so a phone that slept with deviceVisible=true would come back
+      // still claiming to be visible and suppress push for every device.
+      // Reset and wait for the client's connect-time heartbeat (one round
+      // trip). The staleness window below is the independent second guard.
+      socket.data.deviceVisible = false;
+    }
+    socket.on('device_visibility', (payload = {}) => {
+      const deviceId = String(payload?.deviceId || '').trim();
+      if (deviceId) socket.data.deviceId = deviceId;
+      socket.data.deviceVisible = payload?.visible === true;
+      socket.data.deviceVisibleAt = now();
+    });
+  }
+
+  function hasActiveDevice() {
+    for (const socket of getSockets()) {
+      if (!socket || socket.connected === false) continue;
+      if (socket.data?.deviceVisible !== true) continue;
+      const visibleAt = Number(socket.data?.deviceVisibleAt || 0);
+      if (!Number.isFinite(visibleAt) || visibleAt <= 0) continue;
+      if ((now() - visibleAt) > staleMs) continue;
+      return true;
+    }
+    return false;
+  }
+
+  return { registerSocket, hasActiveDevice };
+}