fix(search): keep a bulk lane bucket large enough for one valid reservation

At the smallest supported budgets the 90% share floored below a single
request or token cost and locked the bulk lane. The bucket now holds at least
the reservation it is asked for, while the refill rate keeps the share.

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01JBacX6HGVhPMUySuMfANwn

Author: waleedlatif1

apps/sim/lib/core/rate-limiter/provider-admission.test.ts

@@ -3,10 +3,16 @@
  */
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
 
-const { consumeTokens, getCooldownUntil, setCooldownUntil } = vi.hoisted(() => ({
+const { consumeTokens, getCooldownUntil, setCooldownUntil, mockEnv } = vi.hoisted(() => ({
   consumeTokens: vi.fn(),
   getCooldownUntil: vi.fn(),
   setCooldownUntil: vi.fn(),
+  mockEnv: {} as Record<string, string | undefined>,
+}))
+vi.mock('@/lib/core/config/env', () => ({
+  env: mockEnv,
+  envNumber: (value: string | undefined, fallback: number) =>
+    value === undefined ? fallback : Number(value),
 }))
 vi.mock('@/lib/core/rate-limiter/storage/factory', () => ({
   createStorageAdapter: () => ({
@@ -118,6 +124,26 @@ describe('provider admission', () => {
     expect(interactiveOptions.cooldownKeys).toEqual(bulkOptions.cooldownKeys)
   })
 
+  it('never shrinks a bulk bucket below one valid reservation', async () => {
+    mockEnv.KB_CONFIG_EMBEDDING_REQUESTS_PER_MINUTE = '1'
+    mockEnv.KB_CONFIG_EMBEDDING_TOKENS_PER_MINUTE = '100'
+    try {
+      await waitForProviderAdmission({ ...INPUT, inputTokens: 95, lane: 'bulk' })
+    } finally {
+      mockEnv.KB_CONFIG_EMBEDDING_REQUESTS_PER_MINUTE = undefined
+      mockEnv.KB_CONFIG_EMBEDDING_TOKENS_PER_MINUTE = undefined
+    }
+    expect(consumeTokens.mock.calls[0][0]).toMatchObject([
+      { key: 'provider:embedding:openai:hashed-credential:tokens', config: { maxTokens: 100 } },
+      { key: 'provider:embedding:openai:hashed-credential:requests', config: { maxTokens: 1 } },
+      { key: 'provider:embedding:openai:hashed-credential:bulk:tokens', config: { maxTokens: 95 } },
+      {
+        key: 'provider:embedding:openai:hashed-credential:bulk:requests',
+        config: { maxTokens: 1 },
+      },
+    ])
+  })
+
   it('isolates another credential and does not impose token costs on OCR', async () => {
     await waitForProviderAdmission({
       ...INPUT,

apps/sim/lib/core/rate-limiter/provider-admission.ts

@@ -83,20 +83,24 @@ export async function waitForProviderAdmission(input: ProviderAdmissionInput): P
     requestsPerMinute
   )
   const reservations: TokenBucketReservation[] = []
+  /** A lane bucket always holds at least one valid reservation, so a tiny budget cannot lock the lane. */
   const reserveBuckets = (bucketKey: string, share: number) => {
     if (tokenBudget) {
-      const maxTokens = Math.floor(tokenBudget.perMinute * share)
       reservations.push({
         key: `${bucketKey}:tokens`,
         cost: tokenBudget.cost,
-        config: { maxTokens, refillRate: maxTokens / 60, refillIntervalMs: 1000 },
+        config: {
+          maxTokens: Math.max(tokenBudget.cost, Math.floor(tokenBudget.perMinute * share)),
+          refillRate: (tokenBudget.perMinute * share) / 60,
+          refillIntervalMs: 1000,
+        },
       })
     }
     reservations.push({
       key: `${bucketKey}:requests`,
       cost: 1,
       config: {
-        maxTokens: Math.floor(requestBurst * share),
+        maxTokens: Math.max(1, Math.floor(requestBurst * share)),
         refillRate: (requestsPerMinute * share) / 60,
         refillIntervalMs: 1000,
       },