Simplify freebuff model picker changes

Author: jahooma

cli/src/components/freebuff-model-selector.tsx

@@ -18,10 +18,7 @@ import { useFreebuffModelStore } from '../state/freebuff-model-store'
 import { useFreebuffSessionStore } from '../state/freebuff-session-store'
 import { useTerminalDimensions } from '../hooks/use-terminal-dimensions'
 import { useTheme } from '../hooks/use-theme'
-import {
-  nextFreebuffModelId,
-  resolveFreebuffModelCommitTarget,
-} from '../utils/freebuff-model-navigation'
+import { nextFreebuffModelId } from '../utils/freebuff-model-navigation'
 
 import type { KeyEvent } from '@opentui/core'
 
@@ -203,14 +200,9 @@ export const FreebuffModelSelector: React.FC = () => {
           name === 'return' || name === 'enter' || name === 'space'
         if (!isForward && !isBackward && !isCommit) return
         if (isCommit) {
-          const targetId = resolveFreebuffModelCommitTarget({
-            focusedId,
-            committedId: committedModelId,
-            isSelectable: isJoinable,
-          })
-          if (targetId) {
+          if (isJoinable(focusedId) && focusedId !== committedModelId) {
             key.preventDefault?.()
-            pick(targetId)
+            pick(focusedId)
           }
           return
         }

cli/src/hooks/use-freebuff-session.ts

@@ -532,19 +532,11 @@ export function useFreebuffSession(): UseFreebuffSessionResult {
               ) {
                 return
               }
-              const depths =
-                response.status === 'none' || response.status === 'queued'
-                  ? response.queueDepthByModel
-                  : undefined
-              const rateLimits =
-                'rateLimitsByModel' in response
-                  ? response.rateLimitsByModel
-                  : undefined
-              if (depths || rateLimits) {
+              if (response.status === 'none' || response.status === 'queued') {
                 apply({
                   status: 'none',
-                  ...(depths ? { queueDepthByModel: depths } : {}),
-                  ...(rateLimits ? { rateLimitsByModel: rateLimits } : {}),
+                  queueDepthByModel: response.queueDepthByModel,
+                  rateLimitsByModel: response.rateLimitsByModel,
                 })
               }
             })

cli/src/utils/__tests__/freebuff-model-navigation.test.ts

@@ -1,9 +1,6 @@
 import { describe, expect, test } from 'bun:test'
 
-import {
-  nextFreebuffModelId,
-  resolveFreebuffModelCommitTarget,
-} from '../freebuff-model-navigation'
+import { nextFreebuffModelId } from '../freebuff-model-navigation'
 
 describe('nextFreebuffModelId', () => {
   test('moves to the next model when moving forward', () => {
@@ -52,35 +49,3 @@ describe('nextFreebuffModelId', () => {
     ).toBeNull()
   })
 })
-
-describe('resolveFreebuffModelCommitTarget', () => {
-  test('returns null when focus is on a closed model', () => {
-    expect(
-      resolveFreebuffModelCommitTarget({
-        focusedId: 'glm',
-        committedId: null,
-        isSelectable: (id) => id !== 'glm',
-      }),
-    ).toBeNull()
-  })
-
-  test('commits the focused model when it is selectable', () => {
-    expect(
-      resolveFreebuffModelCommitTarget({
-        focusedId: 'minimax',
-        committedId: null,
-        isSelectable: (id) => id === 'minimax',
-      }),
-    ).toBe('minimax')
-  })
-
-  test('returns null when the target is already committed', () => {
-    expect(
-      resolveFreebuffModelCommitTarget({
-        focusedId: 'minimax',
-        committedId: 'minimax',
-        isSelectable: () => true,
-      }),
-    ).toBeNull()
-  })
-})

cli/src/utils/freebuff-model-navigation.ts

@@ -12,14 +12,3 @@ export function nextFreebuffModelId(params: {
   const step = direction === 'forward' ? 1 : -1
   return modelIds[(currentIdx + step + modelIds.length) % modelIds.length]
 }
-
-export function resolveFreebuffModelCommitTarget(params: {
-  focusedId: string
-  committedId: string | null
-  isSelectable: (modelId: string) => boolean
-}): string | null {
-  const { focusedId, committedId, isSelectable } = params
-
-  if (!isSelectable(focusedId) || focusedId === committedId) return null
-  return focusedId
-}

web/src/server/free-session/public-api.ts

@@ -90,17 +90,14 @@ async function fetchRateLimitSnapshot(
   }
 }
 
-async function fetchRateLimitSnapshotsByModel(
+async function fetchRateLimitsByModel(
   userId: string,
   deps: SessionDeps,
-  opts: { includeUnused?: boolean } = {},
 ): Promise<Record<string, FreebuffSessionRateLimit>> {
   const entries = await Promise.all(
     Object.keys(RATE_LIMITS).map(async (model) => {
       const snapshot = await fetchRateLimitSnapshot(userId, model, deps)
-      return snapshot && (opts.includeUnused || snapshot.info.recentCount > 0)
-        ? ([model, snapshot.info] as const)
-        : null
+      return snapshot ? ([model, snapshot.info] as const) : null
     }),
   )
   return Object.fromEntries(
@@ -111,6 +108,16 @@ async function fetchRateLimitSnapshotsByModel(
   )
 }
 
+function onlyUsedRateLimitsByModel(
+  rateLimitsByModel: Record<string, FreebuffSessionRateLimit>,
+): Record<string, FreebuffSessionRateLimit> {
+  return Object.fromEntries(
+    Object.entries(rateLimitsByModel).filter(
+      ([, snapshot]) => snapshot.recentCount > 0,
+    ),
+  )
+}
+
 function nonEmptyRateLimitsByModel(
   rateLimitsByModel: Record<string, FreebuffSessionRateLimit>,
 ): { rateLimitsByModel: Record<string, FreebuffSessionRateLimit> } | {} {
@@ -397,21 +404,14 @@ async function attachRateLimit(
     return snapshot ? { ...view, rateLimit: snapshot.info } : view
   }
 
-  const allRateLimitsByModel = await fetchRateLimitSnapshotsByModel(
-    userId,
-    deps,
-    { includeUnused: true },
-  )
+  const allRateLimitsByModel = await fetchRateLimitsByModel(userId, deps)
   const rateLimit = allRateLimitsByModel[view.model]
-  const rateLimitsByModel = Object.fromEntries(
-    Object.entries(allRateLimitsByModel).filter(
-      ([, snapshot]) => snapshot.recentCount > 0,
-    ),
-  )
   return {
     ...view,
     ...(rateLimit ? { rateLimit } : {}),
-    ...nonEmptyRateLimitsByModel(rateLimitsByModel),
+    ...nonEmptyRateLimitsByModel(
+      onlyUsedRateLimitsByModel(allRateLimitsByModel),
+    ),
   }
 }
 
@@ -454,12 +454,14 @@ export async function getSessionState(params: {
   const noneResponse = async (): Promise<FreebuffSessionServerResponse> => {
     const [queueDepthByModel, rateLimitsByModel] = await Promise.all([
       deps.queueDepthsByModel(),
-      fetchRateLimitSnapshotsByModel(params.userId, deps),
+      fetchRateLimitsByModel(params.userId, deps),
     ])
     return {
       status: 'none',
       queueDepthByModel,
-      ...nonEmptyRateLimitsByModel(rateLimitsByModel),
+      ...nonEmptyRateLimitsByModel(
+        onlyUsedRateLimitsByModel(rateLimitsByModel),
+      ),
     }
   }