vocs 2.7.2 → 2.8.1

package/src/internal/promise.test.ts

@@ -0,0 +1,90 @@
+import { afterEach, describe, expect, it, vi } from 'vitest'
+import * as promise from './promise.js'
+
+afterEach(() => vi.useRealTimers())
+
+describe('withRetry', () => {
+  it('retries failures', async () => {
+    const fn = vi
+      .fn<() => Promise<string>>()
+      .mockRejectedValueOnce(new Error('failed'))
+      .mockRejectedValueOnce(new Error('failed'))
+      .mockResolvedValueOnce('ok')
+
+    await expect(promise.withRetry(fn, { baseMs: 0 })).resolves.toBe('ok')
+    expect(fn).toHaveBeenCalledTimes(3)
+  })
+
+  it('throws after exhausting retries', async () => {
+    const error = new Error('failed')
+    const fn = vi.fn().mockRejectedValue(error)
+
+    await expect(promise.withRetry(fn, { baseMs: 0 })).rejects.toBe(error)
+    expect(fn).toHaveBeenCalledTimes(3)
+  })
+
+  it('only retries matching failures', async () => {
+    const error = new Error('invalid request')
+    const fn = vi.fn().mockRejectedValue(error)
+
+    await expect(
+      promise.withRetry(fn, {
+        baseMs: 0,
+        shouldRetry: (error) => error instanceof TypeError,
+      }),
+    ).rejects.toBe(error)
+    expect(fn).toHaveBeenCalledOnce()
+  })
+
+  it('stops retrying when aborted', async () => {
+    const controller = new AbortController()
+    const fn = vi.fn().mockImplementation(async () => {
+      controller.abort(new Error('aborted'))
+      throw new Error('failed')
+    })
+
+    await expect(
+      promise.withRetry(fn, {
+        baseMs: 0,
+        signal: controller.signal,
+      }),
+    ).rejects.toThrow('failed')
+    expect(fn).toHaveBeenCalledOnce()
+  })
+
+  it('cancels the retry delay when aborted', async () => {
+    const controller = new AbortController()
+    const error = new Error('aborted')
+    const fn = vi.fn().mockRejectedValue(new Error('failed'))
+    const retry = promise.withRetry(fn, {
+      baseMs: 100,
+      signal: controller.signal,
+    })
+
+    setTimeout(() => controller.abort(error), 0)
+
+    await expect(retry).rejects.toBe(error)
+    expect(fn).toHaveBeenCalledOnce()
+  })
+
+  it('backs off exponentially', async () => {
+    vi.useFakeTimers()
+    const fn = vi
+      .fn<() => Promise<string>>()
+      .mockRejectedValueOnce(new Error('failed'))
+      .mockRejectedValueOnce(new Error('failed'))
+      .mockResolvedValueOnce('ok')
+    const retry = promise.withRetry(fn, { baseMs: 100 })
+
+    await vi.advanceTimersByTimeAsync(99)
+    expect(fn).toHaveBeenCalledOnce()
+    await vi.advanceTimersByTimeAsync(1)
+    expect(fn).toHaveBeenCalledTimes(2)
+    await vi.advanceTimersByTimeAsync(199)
+    expect(fn).toHaveBeenCalledTimes(2)
+    await vi.advanceTimersByTimeAsync(1)
+
+    await expect(retry).resolves.toBe('ok')
+    expect(fn).toHaveBeenCalledTimes(3)
+  })
+})

package/src/internal/promise.ts

@@ -0,0 +1,41 @@
+export async function withRetry<value>(
+  fn: () => Promise<value>,
+  options: withRetry.Options = {},
+): Promise<value> {
+  const { baseMs = 250, retries = 2, shouldRetry = () => true, signal } = options
+  for (let attempt = 0; ; attempt++) {
+    try {
+      return await fn()
+    } catch (error) {
+      if (signal?.aborted || attempt >= retries || !shouldRetry(error)) throw error
+      await wait(baseMs * 2 ** attempt, signal)
+    }
+  }
+}
+
+export declare namespace withRetry {
+  type Options = {
+    baseMs?: number | undefined
+    retries?: number | undefined
+    shouldRetry?: ((error: unknown) => boolean) | undefined
+    signal?: AbortSignal | null | undefined
+  }
+}
+
+async function wait(delay: number, signal?: AbortSignal | null): Promise<void> {
+  if (signal?.aborted) throw signal.reason
+  await new Promise<void>((resolve, reject) => {
+    const timeout = setTimeout(done, delay)
+    signal?.addEventListener('abort', aborted, { once: true })
+
+    function aborted() {
+      clearTimeout(timeout)
+      reject(signal?.reason)
+    }
+
+    function done() {
+      signal?.removeEventListener('abort', aborted)
+      resolve()
+    }
+  })
+}

package/src/internal/reranker.ts

@@ -15,6 +15,8 @@
  * private `_localRetriever` config — never in serializable config sent to the browser.
  */
 
+import * as promise from './promise.js'
+
 export type RerankContext = {
   /** Optional abort signal to cancel the request. */
   signal?: AbortSignal | undefined
@@ -111,20 +113,27 @@ export function cloudflare(options: cloudflare.Options = {}): Adapter {
       if (!apiToken)
         throw new Error('[vocs] Reranker.cloudflare: missing `apiToken` (or CLOUDFLARE_API_TOKEN).')
       const url = `${baseUrl.replace(/\/$/, '')}/accounts/${accountId}/ai/run/${model}`
-      const response = await fetch(url, {
-        method: 'POST',
-        headers: {
-          Authorization: `Bearer ${apiToken}`,
-          'Content-Type': 'application/json',
-          ...headers,
+      const response = await promise.withRetry(
+        () =>
+          fetch(url, {
+            method: 'POST',
+            headers: {
+              Authorization: `Bearer ${apiToken}`,
+              'Content-Type': 'application/json',
+              ...headers,
+            },
+            body: JSON.stringify({
+              query,
+              contexts: documents.map((text) => ({ text })),
+              ...(context.topK ? { top_k: context.topK } : {}),
+            }),
+            signal: context.signal ?? null,
+          }),
+        {
+          shouldRetry: (error) => error instanceof TypeError,
+          signal: context.signal,
         },
-        body: JSON.stringify({
-          query,
-          contexts: documents.map((text) => ({ text })),
-          ...(context.topK ? { top_k: context.topK } : {}),
-        }),
-        signal: context.signal ?? null,
-      })
+      )
       if (!response.ok)
         throw new Error(
           `[vocs] cloudflare rerank failed (${response.status}): ${await safeText(response)}`,

package/src/internal/vector-store.ts

@@ -14,6 +14,8 @@
  *   runtime, so no index artifact ships with the server bundle.
  */
 
+import * as promise from './promise.js'
+
 export type Format = 'float32' | 'int8'
 
 export type Adapter = StaticAdapter | RemoteAdapter
@@ -170,16 +172,23 @@ export function cloudflare(options: cloudflare.Options = {}): RemoteAdapter {
         '[vocs] VectorStore.cloudflare: missing `apiToken` (or CLOUDFLARE_API_TOKEN).',
       )
     const url = `${baseUrl.replace(/\/$/, '')}/accounts/${accountId}/vectorize/v2/indexes${path}`
-    return await fetch(url, {
-      method: init.method ?? 'GET',
-      headers: {
-        Authorization: `Bearer ${apiToken}`,
-        ...(init.contentType ? { 'Content-Type': init.contentType } : {}),
-        ...headers,
+    return await promise.withRetry(
+      () =>
+        fetch(url, {
+          method: init.method ?? 'GET',
+          headers: {
+            Authorization: `Bearer ${apiToken}`,
+            ...(init.contentType ? { 'Content-Type': init.contentType } : {}),
+            ...headers,
+          },
+          ...(init.body !== undefined ? { body: init.body } : {}),
+          signal: init.signal ?? null,
+        }),
+      {
+        shouldRetry: (error) => error instanceof TypeError,
+        signal: init.signal,
       },
-      ...(init.body !== undefined ? { body: init.body } : {}),
-      signal: init.signal ?? null,
-    })
+    )
   }
 
   /** Creates the index when missing; validates dimensions when present. */

package/src/mdx.tsx

@@ -1,6 +1,7 @@
 import type { MDXComponents } from 'mdx/types.js'
 
 import { Callout } from './react/Callout.js'
+import { Benchmarks } from './react/internal/Benchmarks.mdx.js'
 import { Changelog } from './react/internal/Changelog.mdx.js'
 import { CodeBlock } from './react/internal/CodeBlock.mdx.js'
 import { CodeGroup } from './react/internal/CodeGroup.mdx.js'
@@ -36,6 +37,7 @@ export const components: MDXComponents = {
       }
     >,
   ) {
+    if ('data-v-benchmarks' in props) return <Benchmarks {...props} />
     if ('data-v-changelog' in props) return <Changelog {...props} />
     if ('data-v-code-group' in props) return <CodeGroup {...props} />
     if ('data-v-file-tree' in props) return <FileTree {...props} />

package/src/react/internal/Benchmarks.mdx.tsx

@@ -0,0 +1,30 @@
+import type * as React from 'react'
+
+export function Benchmarks(props: Benchmarks.Props) {
+  const { children, legend, scalar: _scalar, ...rest } = props
+  return (
+    <div {...rest} data-v data-v-benchmarks>
+      {children}
+      {legend !== 'false' && (
+        <footer data-v-benchmarks-legend>
+          <span>Faster</span>
+          <span data-v-benchmarks-legend-scale />
+          <span>Slower</span>
+          <span data-v-benchmarks-legend-baseline>
+            <span data-v-benchmarks-legend-swatch />
+            baseline
+          </span>
+        </footer>
+      )}
+    </div>
+  )
+}
+
+export declare namespace Benchmarks {
+  type Props = React.PropsWithChildren<
+    React.ComponentProps<'div'> & {
+      legend?: string | undefined
+      scalar?: string | undefined
+    }
+  >
+}