Sync public snapshot from freebuff-private

Source: CodebuffAI/freebuff-private@251b13a5a88d199924cca1e512eefbe99435d94e

Author: github-actions[bot]

cli/src/hooks/helpers/__tests__/send-message.test.ts

@@ -1,4 +1,12 @@
-import { describe, expect, test, mock, beforeEach, afterEach } from 'bun:test'
+import {
+  describe,
+  expect,
+  test,
+  mock,
+  beforeEach,
+  afterEach,
+  spyOn,
+} from 'bun:test'
 import { FREEBUFF_PROVIDER_USAGE_MESSAGE } from '@codebuff/common/constants/freebuff-errors'
 
 import type { ChatMessage } from '../../../types/chat'
@@ -39,6 +47,9 @@ const {
 } = await import('../send-message')
 const { createBatchedMessageUpdater } =
   await import('../../../utils/message-updater')
+const freebuffSession = await import('../../use-freebuff-session')
+const { FREEBUFF_MODEL_UNAVAILABLE_MESSAGE } =
+  await import('../../../utils/error-handling')
 import { createPaymentRequiredError } from '@codebuff/sdk'
 import type { RunState } from '@codebuff/sdk'
 
@@ -2122,4 +2133,88 @@ describe('freebuff gate errors', () => {
     expect(messages[0].userError).toContain('Your free session ended')
     expect(messages[0].userError).not.toContain('server said so')
   })
+
+  describe('model_unavailable', () => {
+    let sessionSpies: Array<ReturnType<typeof spyOn>> = []
+    beforeEach(() => {
+      sessionSpies = [
+        spyOn(freebuffSession, 'markFreebuffSessionEnded'),
+        spyOn(freebuffSession, 'markFreebuffSessionSuperseded'),
+        spyOn(freebuffSession, 'refreshFreebuffSession').mockResolvedValue(
+          undefined,
+        ),
+      ]
+    })
+    afterEach(() => {
+      for (const spy of sessionSpies) spy.mockRestore()
+    })
+
+    const runCompletionWith = (output: Record<string, unknown>) => {
+      const messages = baseMessage()
+      const updater = makeUpdater(messages)
+      handleRunCompletion({
+        runState: {
+          traceSessionId: 'trace-test',
+          sessionState: undefined as any,
+          output: output as any,
+        },
+        actualCredits: undefined,
+        agentMode: 'LITE',
+        timerController: createMockTimerController(),
+        updater,
+        aiMessageId: 'ai-1',
+        wasAbortedByUser: false,
+        setStreamStatus: () => {},
+        setCanProcessQueue: () => {},
+        updateChainInProgress: () => {},
+        setHasReceivedPlanResponse: () => {},
+      })
+      updater.flush()
+      return messages
+    }
+
+    test('handleRunCompletion shows the server message and keeps the session', () => {
+      const serverMessage =
+        'DeepSeek V4 Pro has been withdrawn from Freebuff. Switch to GLM 5.3 Flash to continue.'
+      const messages = runCompletionWith({
+        type: 'error',
+        message: serverMessage,
+        error: 'model_unavailable',
+        statusCode: 410,
+      })
+      expect(messages[0].userError).toBe(serverMessage)
+      expect(messages[0].isComplete).toBe(true)
+      for (const spy of sessionSpies) expect(spy).not.toHaveBeenCalled()
+    })
+
+    test('a session-ending code still ends the session (spy control)', () => {
+      runCompletionWith({
+        type: 'error',
+        message: 'server said so',
+        error: 'session_expired',
+        statusCode: 410,
+      })
+      expect(sessionSpies[0]).toHaveBeenCalledTimes(1)
+    })
+
+    test('handleRunError falls back to a default when the server sent no message', () => {
+      const messages = baseMessage()
+      const updater = makeUpdater(messages)
+      handleRunError({
+        error: Object.assign(new Error(''), {
+          error: 'model_unavailable',
+          statusCode: 410,
+        }),
+        timerController: createMockTimerController(),
+        updater,
+        setIsRetrying: () => {},
+        setStreamStatus: () => {},
+        setCanProcessQueue: () => {},
+        updateChainInProgress: () => {},
+      })
+      updater.flush()
+      expect(messages[0].userError).toBe(FREEBUFF_MODEL_UNAVAILABLE_MESSAGE)
+      for (const spy of sessionSpies) expect(spy).not.toHaveBeenCalled()
+    })
+  })
 })

cli/src/hooks/helpers/send-message.ts

@@ -21,6 +21,7 @@ import {
   isOutOfCreditsError,
   isFreebuffProviderUsageError,
   isFreeModeUnavailableError,
+  FREEBUFF_MODEL_UNAVAILABLE_MESSAGE,
   OUT_OF_CREDITS_MESSAGE,
 } from '../../utils/error-handling'
 import { formatElapsedTime } from '../../utils/format-elapsed-time'
@@ -45,6 +46,7 @@ import type {
 } from '../../types/store'
 import type { ChatMessage } from '../../types/chat'
 import type { AgentMode } from '../../utils/constants'
+import type { FreebuffGateErrorKind } from '../../utils/error-handling'
 import type { SendMessageTimerController } from '../../utils/send-message-timer'
 import type { StreamController } from '../stream-state'
 import type { StreamStatus } from '../use-message-queue'
@@ -435,6 +437,7 @@ export const handleRunCompletion = (params: {
     if (!isByokRun && gateKind) {
       handleFreebuffGateError(gateKind, updater, {
         messageWasDropped: params.hasReceivedContent === false,
+        serverMessage: output.message,
       })
       finalizeAfterError()
       return
@@ -562,6 +565,7 @@ export const handleRunError = (params: {
   if (!isByokRun && gateKind) {
     handleFreebuffGateError(gateKind, updater, {
       messageWasDropped: hasReceivedContent === false,
+      serverMessage: errorInfo.message,
     })
     return
   }
@@ -585,9 +589,9 @@ export const handleRunError = (params: {
  * the UI reflects reality and we stop sending requests until we re-admit.
  */
 function handleFreebuffGateError(
-  kind: ReturnType<typeof getFreebuffGateErrorKind>,
+  kind: FreebuffGateErrorKind,
   updater: BatchedMessageUpdater,
-  opts: { messageWasDropped?: boolean } = {},
+  opts: { messageWasDropped?: boolean; serverMessage?: string } = {},
 ) {
   switch (kind) {
     case 'session_expired':
@@ -632,7 +636,24 @@ function handleFreebuffGateError(
       // so we don't silently fight the other instance for the seat.
       markFreebuffSessionSuperseded()
       return
-    default:
+    case 'model_unavailable':
+      // The model was withdrawn from free mode. Terminal for this request
+      // only: the session survives (`endsTheSession: false`), so neither end it
+      // nor re-admit — that is the re-admission loop the code exists to avoid.
+      // The server's message names the replacement model.
+      updater.setError(
+        opts.serverMessage?.trim() || FREEBUFF_MODEL_UNAVAILABLE_MESSAGE,
+      )
+      return
+    default: {
+      // A new gate code must get its own case, never a silent no-op.
+      const unhandled: never = kind
+      updater.setError(
+        opts.serverMessage?.trim() ||
+          'Freebuff could not run this turn on your free session.',
+      )
+      logger.warn({ kind: unhandled }, 'Unhandled freebuff gate error kind')
       return
+    }
   }
 }

cli/src/utils/__tests__/error-handling.test.ts

@@ -6,6 +6,7 @@ import {
 } from '@codebuff/common/constants/freebuff-errors'
 
 import {
+  getFreebuffGateErrorKind,
   getFreebuffRateLimitErrorMessage,
   getFreeModeUnavailableErrorMessage,
   isOutOfCreditsError,
@@ -693,3 +694,27 @@ describe('error-handling', () => {
     })
   })
 })
+
+describe('getFreebuffGateErrorKind', () => {
+  test('classifies a 410 model_unavailable refusal', () => {
+    expect(
+      getFreebuffGateErrorKind({ error: 'model_unavailable', statusCode: 410 }),
+    ).toBe('model_unavailable')
+  })
+
+  test('requires the code and its status to match', () => {
+    expect(
+      getFreebuffGateErrorKind({ error: 'model_unavailable', statusCode: 409 }),
+    ).toBe(null)
+    expect(getFreebuffGateErrorKind({ error: 'model_unavailable' })).toBe(null)
+  })
+
+  test('leaves session_limit_reached to its own handler', () => {
+    expect(
+      getFreebuffGateErrorKind({
+        error: 'session_limit_reached',
+        statusCode: 409,
+      }),
+    ).toBe(null)
+  })
+})

cli/src/utils/error-handling.ts

@@ -249,6 +249,10 @@ export const OUT_OF_CREDITS_MESSAGE = `Out of credits. Please add credits at ${d
 export const FREEBUFF_RATE_LIMIT_MESSAGE =
   'Freebuff is temporarily busy. Please try again in a moment.'
 
+/** Fallback for a `model_unavailable` gate refusal without a server message. */
+export const FREEBUFF_MODEL_UNAVAILABLE_MESSAGE =
+  'This model is no longer available in Freebuff. Pick another model with /model and send your message again.'
+
 export const FREE_MODE_UNAVAILABLE_MESSAGE = IS_FREEBUFF
   ? 'Freebuff is not available in your country.'
   : 'Free mode is not available in your country. You can use another mode to continue.'