@aurabase/aurabase-js 0.3.0

package/packages/ai/src/AiService.ts

@@ -0,0 +1,226 @@
+import { BaseService } from '@aurabase/core'
+import { AuraError, isTokenExpired, refreshOnce, isAbortError } from '@aurabase/core'
+import type {
+  AuraResponse,
+  ChatMessage,
+  ChatResponse,
+  EmbedRequest,
+  EmbedResponse,
+  RagIngestRequest,
+  RagIngestResponse,
+  RagRequest,
+  RagResponse,
+  SemanticSearchResult,
+} from '@aurabase/core'
+import type { AuraClientLike } from '@aurabase/core'
+import { parseSSE, type ChatStreamChunk, type ChatStreamFinal } from './sse'
+import type { RagNamespace, RagDeleteResponse, RagReindexResponse } from './types'
+
+export class AiService extends BaseService {
+  constructor(client: AuraClientLike) {
+    super(client)
+  }
+
+  private get prefix(): string {
+    return `/v1/ai/${this.client.projectId}`
+  }
+
+  /**
+   * Send a chat completion request.
+   */
+  async chat(
+    messages: ChatMessage[],
+    options?: { model?: string; temperature?: number; max_tokens?: number },
+  ): Promise<AuraResponse<ChatResponse>> {
+    return this.request('POST', `${this.prefix}/chat`, {
+      messages,
+      ...options,
+    })
+  }
+
+  /**
+   * Chat completion streamé (SSE). Renvoie un `AsyncIterable` de deltas de tokens,
+   * consommable par `for await (const { delta } of ai.chatStream(msgs)) { … }`.
+   *
+   * Court-circuite volontairement le pipeline JSON (`@aurabase/core/fetch.ts`) et
+   * emprunte le chemin transport BRUT `client.fetchFn` (patron `StorageService.download`) :
+   *  - refresh proactif du token expiré (même règle que `download`, marge 30 s) ;
+   *  - pose manuelle de `Authorization: Bearer` + `apikey`, `Accept: text/event-stream` ;
+   *  - lecture de `res.body` via `parseSSE`, mapping des events serveur :
+   *    `delta` (`{ content }`) → `yield { delta }`, `error` (`{ error }`) → lève une
+   *    `AuraError`, `done` → termine l'itération.
+   *
+   * `options.signal` interrompt proprement le flux (annulation du `fetch` + fin
+   * d'itération sans throw). Sur `!res.ok`, lève `AuraError(res.status)`.
+   *
+   * Backend route: POST /v1/ai/{project_id}/chat/stream
+   */
+  async *chatStream(
+    messages: ChatMessage[],
+    options?: { model?: string; temperature?: number; max_tokens?: number; signal?: AbortSignal },
+  ): AsyncGenerator<ChatStreamChunk> {
+    const client = this.client
+    const store = client.authStore
+    // Refresh proactif AVANT d'ouvrir le flux (aligné sur download()).
+    if (store.token && store.refreshToken && isTokenExpired(store.token, 30)) {
+      await refreshOnce(client)
+    }
+    const headers: Record<string, string> = {
+      'Content-Type': 'application/json',
+      Accept: 'text/event-stream',
+    }
+    if (store.token) headers['Authorization'] = `Bearer ${store.token}`
+    if (client.apiKey) headers['apikey'] = client.apiKey
+
+    const body = JSON.stringify({
+      messages,
+      model: options?.model,
+      temperature: options?.temperature,
+      max_tokens: options?.max_tokens,
+    })
+
+    try {
+      const res = await client.fetchFn(this.url(`${this.prefix}/chat/stream`), {
+        method: 'POST',
+        headers,
+        body,
+        signal: options?.signal,
+      })
+      if (!res.ok) {
+        let parsed: { error?: { code?: string; message?: string }; message?: string } | null = null
+        try {
+          parsed = (await res.json()) as typeof parsed
+        } catch {
+          // corps non-JSON / vide → AuraError générique sur le status
+        }
+        throw new AuraError(res.status, parsed)
+      }
+      if (!res.body) {
+        throw new AuraError(0, {
+          error: { code: 'invalid_response', message: 'chatStream: la réponse SSE n\'a pas de corps lisible' },
+        })
+      }
+      for await (const msg of parseSSE(res.body as ReadableStream<Uint8Array>)) {
+        if (msg.event === 'delta') {
+          let content = ''
+          try {
+            content = (JSON.parse(msg.data) as { content?: string }).content ?? ''
+          } catch {
+            content = ''
+          }
+          if (content) yield { delta: content }
+        } else if (msg.event === 'error') {
+          let message = 'AI stream error'
+          try {
+            message = (JSON.parse(msg.data) as { error?: string }).error ?? message
+          } catch {
+            // conserve le message par défaut
+          }
+          throw new AuraError(0, { error: { code: 'ai_stream_error', message } })
+        } else if (msg.event === 'done') {
+          // Le serveur joint au `done` le provider effectif, la bascule éventuelle,
+          // le motif d'arrêt et l'usage réel. Les jeter privait l'application de
+          // toute visibilité sur une réponse tronquée et sur sa consommation.
+          let final: ChatStreamFinal | undefined
+          try {
+            const parsed = JSON.parse(msg.data) as ChatStreamFinal & { status?: string }
+            const { status: _status, ...rest } = parsed
+            // Un chunk final n'est émis QUE s'il apporte quelque chose : face à un
+            // serveur plus ancien (`done` réduit à `[DONE]`), l'itération se termine
+            // exactement comme avant — aucun chunk supplémentaire à filtrer.
+            if (Object.keys(rest).length > 0) final = rest
+          } catch {
+            final = undefined
+          }
+          if (final) yield { delta: '', final }
+          return
+        }
+      }
+    } catch (err) {
+      // Annulation demandée → fin d'itération PROPRE (pas de throw), parité avec
+      // une consommation interrompue via AbortController.
+      if (options?.signal?.aborted || isAbortError(err)) return
+      throw err
+    }
+  }
+
+  /**
+   * Generate embeddings for the given input(s).
+   */
+  async embed(req: EmbedRequest): Promise<AuraResponse<EmbedResponse>> {
+    return this.request('POST', `${this.prefix}/embed`, req)
+  }
+
+  /**
+   * Retrieval-Augmented Generation: query a collection and get an answer.
+   */
+  async rag(req: RagRequest): Promise<AuraResponse<RagResponse>> {
+    return this.request('POST', `${this.prefix}/rag/query`, req)
+  }
+
+  /**
+   * Ingest a document into a RAG namespace.
+   */
+  async ragIngest(req: RagIngestRequest): Promise<AuraResponse<RagIngestResponse>> {
+    return this.request('POST', `${this.prefix}/rag/ingest`, req)
+  }
+
+  /**
+   * Liste les namespaces RAG du projet.
+   * Backend route: GET /v1/ai/{project_id}/rag/namespaces (→ `Vec<String>`).
+   */
+  async listNamespaces(): Promise<AuraResponse<RagNamespace[]>> {
+    return this.request('GET', `${this.prefix}/rag/namespaces`)
+  }
+
+  /**
+   * Supprime un namespace RAG (et son corpus). Le segment `namespace` est
+   * URL-encodé (anti-injection de chemin).
+   * Backend route: DELETE /v1/ai/{project_id}/rag/{namespace} (→ `{ deleted }`).
+   */
+  async deleteNamespace(namespace: string): Promise<AuraResponse<RagDeleteResponse>> {
+    return this.request('DELETE', `${this.prefix}/rag/${encodeURIComponent(namespace)}`)
+  }
+
+  /**
+   * Ré-indexe un namespace RAG avec le modèle d'embedding courant (remédiation
+   * après un changement de modèle/dimension). Le segment `namespace` est URL-encodé.
+   * Backend route: POST /v1/ai/{project_id}/rag/{namespace}/reindex (→ `ReindexResponse`).
+   */
+  async reindexNamespace(namespace: string): Promise<AuraResponse<RagReindexResponse>> {
+    return this.request('POST', `${this.prefix}/rag/${encodeURIComponent(namespace)}/reindex`)
+  }
+
+  /**
+   * Semantic search over an embedding namespace.
+   */
+  async semanticSearch(
+    query: string,
+    namespace: string,
+    options?: { top_k?: number; threshold?: number },
+  ): Promise<AuraResponse<SemanticSearchResult[]>> {
+    const params = new URLSearchParams({ query, namespace })
+    if (options?.top_k !== undefined) params.set('top_k', String(options.top_k))
+    if (options?.threshold !== undefined) params.set('threshold', String(options.threshold))
+    return this.request('GET', `${this.prefix}/search?${params.toString()}`)
+  }
+
+  /**
+   * Natural-language to SQL: convert a question into a SQL query.
+   */
+  async nl2sql(
+    question: string,
+    schema: string,
+    options?: {
+      dialect?: string
+      examples?: Array<{ question: string; sql: string }>
+    },
+  ): Promise<AuraResponse<{ sql: string; explanation: string }>> {
+    return this.request('POST', `${this.prefix}/nl2sql`, {
+      question,
+      schema,
+      dialect: options?.dialect,
+      examples: options?.examples,
+    })
+  }
+}

package/packages/ai/src/index.ts

@@ -0,0 +1,18 @@
+export { AiService } from './AiService'
+export { parseSSE } from './sse'
+export type { SSEMessage, ChatStreamChunk } from './sse'
+export type { RagNamespace, RagDeleteResponse, RagReindexResponse } from './types'
+
+// Types publics (utilisables en consommant `@aurabase/ai` seul, sans importer core).
+export type {
+  AuraResponse,
+  ChatMessage,
+  ChatResponse,
+  EmbedRequest,
+  EmbedResponse,
+  RagRequest,
+  RagResponse,
+  RagIngestRequest,
+  RagIngestResponse,
+  SemanticSearchResult,
+} from '@aurabase/core'

package/packages/ai/src/sse.ts

@@ -0,0 +1,141 @@
+// ---------------------------------------------------------------------------
+// Parseur SSE (Server-Sent Events) — utilitaire de streaming côté SDK.
+//
+// Extrait pour être testable en isolation (trames partielles, multi-events par
+// chunk, lignes keep-alive `:`) et réutilisable (chat streaming, futur SSE
+// realtime/functions). NE DÉPEND PAS de `@aurabase/core/fetch.ts` : il opère sur
+// un `ReadableStream<Uint8Array>` brut obtenu via `client.fetchFn` (patron Storage).
+// ---------------------------------------------------------------------------
+
+/** Un message SSE dispatché : nom d'event (`message` par défaut) + données jointes. */
+export interface SSEMessage {
+  event: string
+  data: string
+}
+
+/** Usage de tokens rapporté par le provider à la fin d'un flux. */
+export interface ChatStreamUsage {
+  input_tokens?: number | null
+  /** Tokens de sortie facturés, raisonnement inclus. */
+  output_tokens?: number | null
+  /** Part de `output_tokens` consommée par le raisonnement du modèle. */
+  reasoning_tokens?: number | null
+  /** `true` si les compteurs sont estimés faute d'usage rapporté par le provider. */
+  estimated?: boolean
+}
+
+/**
+ * Dernier chunk d'un flux de chat, émis avant la fin de l'itération.
+ *
+ * Le serveur envoie ces informations dans l'event SSE `done` ; elles étaient
+ * jusqu'ici ignorées par le SDK, si bien qu'une réponse tronquée (`length`) ou la
+ * consommation réelle de tokens restaient invisibles côté application.
+ */
+export interface ChatStreamFinal {
+  /** Provider ayant effectivement répondu. */
+  provider?: string
+  /** `true` si une bascule de fallback a eu lieu. */
+  fallback_used?: boolean
+  /** Motif d'arrêt normalisé : `stop` | `length` | `content_filter` | `tool_use` | `other`. */
+  finish_reason?: string | null
+  /** Raccourci : la réponse a été coupée par la limite de tokens. */
+  truncated?: boolean
+  usage?: ChatStreamUsage
+}
+
+/**
+ * Chunk de streaming de chat.
+ *
+ * `delta` porte le texte incrémental ; le **dernier** chunk du flux porte `final`
+ * (sans `delta`) avec l'usage et le motif d'arrêt. Les consommateurs existants
+ * qui n'utilisent que `delta` continuent de fonctionner : ils reçoivent une
+ * chaîne vide sur ce dernier chunk.
+ */
+export interface ChatStreamChunk {
+  delta: string
+  final?: ChatStreamFinal
+}
+
+/**
+ * Parse un flux SSE en `AsyncGenerator<SSEMessage>`.
+ *
+ * Conforme au protocole EventSource :
+ *  - événements séparés par une ligne vide (`\n\n`) ;
+ *  - champs `event:` / `data:` (espace optionnel après le `:`), autres champs ignorés ;
+ *  - plusieurs `data:` d'un même event sont jointes par `\n` ;
+ *  - lignes commençant par `:` = commentaires/keep-alive → ignorées ;
+ *  - CRLF toléré (le `\r` de fin de ligne est retiré).
+ *
+ * Gère les trames partielles : un event scindé sur plusieurs chunks est
+ * bufferisé jusqu'à réception de la ligne vide. Un éventuel event final non
+ * terminé par une ligne vide est tout de même livré à la fermeture du flux.
+ */
+export async function* parseSSE(
+  stream: ReadableStream<Uint8Array>,
+): AsyncGenerator<SSEMessage> {
+  const reader = stream.getReader()
+  const decoder = new TextDecoder()
+  let buffer = ''
+  let eventName = 'message'
+  let dataLines: string[] = []
+
+  // Consomme une ligne (déjà débarrassée de son `\n` et de son éventuel `\r`).
+  // Renvoie un SSEMessage à dispatcher sur ligne vide, sinon null.
+  const consumeLine = (raw: string): SSEMessage | null => {
+    const line = raw.endsWith('\r') ? raw.slice(0, -1) : raw
+    if (line === '') {
+      // Fin d'event : dispatch si des données ont été accumulées.
+      if (dataLines.length === 0) {
+        eventName = 'message'
+        return null
+      }
+      const msg: SSEMessage = { event: eventName, data: dataLines.join('\n') }
+      eventName = 'message'
+      dataLines = []
+      return msg
+    }
+    if (line.startsWith(':')) return null // commentaire / keep-alive
+    const colon = line.indexOf(':')
+    let field: string
+    let value: string
+    if (colon === -1) {
+      field = line
+      value = ''
+    } else {
+      field = line.slice(0, colon)
+      value = line.slice(colon + 1)
+      if (value.startsWith(' ')) value = value.slice(1)
+    }
+    if (field === 'event') eventName = value
+    else if (field === 'data') dataLines.push(value)
+    // id / retry : ignorés (non pertinents pour le SDK)
+    return null
+  }
+
+  try {
+    for (;;) {
+      const { done, value } = await reader.read()
+      if (done) break
+      buffer += decoder.decode(value, { stream: true })
+      let idx: number
+      while ((idx = buffer.indexOf('\n')) !== -1) {
+        const raw = buffer.slice(0, idx)
+        buffer = buffer.slice(idx + 1)
+        const msg = consumeLine(raw)
+        if (msg) yield msg
+      }
+    }
+    // Vidange du décodeur + traitement d'une éventuelle dernière ligne sans `\n`.
+    buffer += decoder.decode()
+    if (buffer.length > 0) {
+      const msg = consumeLine(buffer)
+      if (msg) yield msg
+    }
+    // Event final non terminé par une ligne vide (data accumulée sans dispatch).
+    if (dataLines.length > 0) {
+      yield { event: eventName, data: dataLines.join('\n') }
+    }
+  } finally {
+    reader.releaseLock()
+  }
+}

package/packages/ai/src/types.ts

@@ -0,0 +1,30 @@
+// ---------------------------------------------------------------------------
+// Types locaux du package @aurabase/ai (non mutualisés dans @aurabase/core).
+// ---------------------------------------------------------------------------
+
+/**
+ * Un namespace RAG. Le backend (`GET /rag/namespaces` → `Vec<String>`) renvoie
+ * de simples chaînes ; le type reste un alias pour documenter l'intention et
+ * autoriser une évolution ultérieure vers un objet sans casser les appelants.
+ */
+export type RagNamespace = string
+
+/**
+ * Réponse de `DELETE /rag/{namespace}` — forme réelle du handler
+ * (`rag_delete_namespace` → `{ "deleted": <count> }`).
+ */
+export interface RagDeleteResponse {
+  /** Nombre d'entrées supprimées du namespace. */
+  deleted: number
+}
+
+/**
+ * Réponse de `POST /rag/{namespace}/reindex` — forme réelle du handler
+ * (`ReindexResponse` dans `services/aura-ai/src/rag/mod.rs`).
+ */
+export interface RagReindexResponse {
+  /** Nombre de chunks ré-embeddés sous le modèle courant. */
+  reindexed: number
+  /** Modèle d'embedding désormais appliqué au namespace. */
+  embedding_model: string
+}

package/packages/ai/tests/chat-stream.test.ts

@@ -0,0 +1,151 @@
+import { describe, it, expect } from 'vitest'
+import { AiService } from '../src/AiService'
+import { BaseAuthStore, isAuraError } from '@aurabase/core'
+import type { AuraClientLike } from '@aurabase/core'
+
+function b64url(o: unknown) { return btoa(JSON.stringify(o)).replace(/\+/g, '-').replace(/\//g, '_').replace(/=+$/, '') }
+function expiredJwt() { return `${b64url({ alg: 'HS256' })}.${b64url({ exp: Math.floor(Date.now() / 1000) - 60 })}.s` }
+function validJwt() { return `${b64url({ alg: 'HS256' })}.${b64url({ exp: Math.floor(Date.now() / 1000) + 3600 })}.s` }
+function fakeUser() { return { id: 'u', email: null, role: 'authenticated', email_verified: true, is_banned: false, is_anonymous: false, mfa_enabled: false, user_metadata: {}, app_metadata: {}, created_at: '2025-01-01T00:00:00Z' } }
+
+function streamResponse(chunks: string[], status = 200): Response {
+  const enc = new TextEncoder()
+  let i = 0
+  const body = new ReadableStream<Uint8Array>({
+    pull(controller) {
+      if (i < chunks.length) controller.enqueue(enc.encode(chunks[i++]))
+      else controller.close()
+    },
+  })
+  return new Response(body, { status, headers: { 'Content-Type': 'text/event-stream' } })
+}
+
+function make(
+  responder: (url: string, init: RequestInit) => Response | Promise<Response>,
+  store = new BaseAuthStore(),
+) {
+  const calls: Array<{ url: string; init: RequestInit }> = []
+  const client: AuraClientLike = {
+    baseUrl: 'http://x', projectId: 'p', apiKey: 'k', authStore: store,
+    fetchFn: (async (url: string, init: RequestInit) => { calls.push({ url: String(url), init }); return responder(String(url), init) }) as unknown as typeof globalThis.fetch,
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    auth: { refreshSession: async () => ({ data: null, error: null }) as any },
+  }
+  return { ai: new AiService(client), calls }
+}
+
+const delta = (c: string) => `event: delta\ndata: ${JSON.stringify({ content: c })}\n\n`
+const done = () => `event: done\ndata: ${JSON.stringify({ status: '[DONE]' })}\n\n`
+
+const doneRiche = () =>
+  `event: done\ndata: ${JSON.stringify({
+    status: '[DONE]',
+    provider: 'google',
+    fallback_used: false,
+    finish_reason: 'length',
+    truncated: true,
+    usage: { input_tokens: 11, output_tokens: 76, reasoning_tokens: 74, estimated: false },
+  })}\n\n`
+
+describe('ai.chatStream — SSE via fetchFn brut', () => {
+  it('livre un chunk final avec usage et motif d’arrêt quand le serveur les fournit', async () => {
+    const { ai } = make(() => streamResponse([delta('Ah, les'), doneRiche()]))
+    const chunks: { delta: string; final?: Record<string, unknown> }[] = []
+    for await (const c of ai.chatStream([{ role: 'user', content: 'hi' }])) chunks.push(c)
+
+    // Le texte reste livré à l'identique…
+    expect(chunks.map((c) => c.delta).join('')).toBe('Ah, les')
+    // …et le dernier chunk porte de quoi détecter une réponse TRONQUÉE, qui était
+    // jusqu'ici indiscernable d'une réponse complète côté application.
+    const final = chunks[chunks.length - 1].final as Record<string, unknown>
+    expect(final).toBeDefined()
+    expect(final.finish_reason).toBe('length')
+    expect(final.truncated).toBe(true)
+    expect(final.provider).toBe('google')
+    // Usage réel, raisonnement inclus (74 des 76 tokens de sortie).
+    expect((final.usage as Record<string, number>).output_tokens).toBe(76)
+    expect((final.usage as Record<string, number>).reasoning_tokens).toBe(74)
+  })
+
+  it('serveur ancien (done sans détail) → aucun chunk final ajouté', async () => {
+    const { ai } = make(() => streamResponse([delta('a'), delta('b'), done()]))
+    const out: string[] = []
+    for await (const c of ai.chatStream([{ role: 'user', content: 'hi' }])) out.push(c.delta)
+    expect(out).toEqual(['a', 'b'])
+  })
+
+  it('livre des deltas incrémentaux puis termine sur done', async () => {
+    const { ai } = make(() => streamResponse([delta('Hel'), delta('lo'), delta('!'), done()]))
+    const out: string[] = []
+    for await (const chunk of ai.chatStream([{ role: 'user', content: 'hi' }])) {
+      out.push(chunk.delta)
+    }
+    expect(out).toEqual(['Hel', 'lo', '!'])
+    expect(out.join('')).toBe('Hello!')
+  })
+
+  it('POST vers /chat/stream avec Accept text/event-stream + apikey + Authorization', async () => {
+    const store = new BaseAuthStore()
+    store.save(validJwt(), 'rt', fakeUser())
+    const { ai, calls } = make(() => streamResponse([done()]), store)
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    for await (const _ of ai.chatStream([{ role: 'user', content: 'hi' }])) { /* drain */ }
+    expect(calls[0]!.url).toBe('http://x/v1/ai/p/chat/stream')
+    expect(calls[0]!.init.method).toBe('POST')
+    const h = calls[0]!.init.headers as Record<string, string>
+    expect(h['Accept']).toBe('text/event-stream')
+    expect(h['apikey']).toBe('k')
+    expect(h['Authorization']).toBe(`Bearer ${store.token}`)
+  })
+
+  it('event error → lève une AuraError exploitable', async () => {
+    const { ai } = make(() => streamResponse([delta('a'), `event: error\ndata: ${JSON.stringify({ error: 'boom' })}\n\n`]))
+    await expect(async () => {
+      // eslint-disable-next-line @typescript-eslint/no-unused-vars
+      for await (const _ of ai.chatStream([{ role: 'user', content: 'hi' }])) { /* drain */ }
+    }).rejects.toSatisfy((e: unknown) => isAuraError(e) && (e as { message: string }).message.includes('boom'))
+  })
+
+  it('!res.ok → lève AuraError(status)', async () => {
+    const { ai } = make(() => new Response(JSON.stringify({ error: { code: 'nope', message: 'x' } }), { status: 429 }))
+    await expect(async () => {
+      // eslint-disable-next-line @typescript-eslint/no-unused-vars
+      for await (const _ of ai.chatStream([{ role: 'user', content: 'hi' }])) { /* drain */ }
+    }).rejects.toSatisfy((e: unknown) => isAuraError(e) && (e as { status: number }).status === 429)
+  })
+
+  it('AbortSignal déjà avorté → fin d’itération propre (aucun delta, pas de throw)', async () => {
+    const ac = new AbortController()
+    ac.abort()
+    const { ai } = make((_url, init) =>
+      init.signal?.aborted
+        ? Promise.reject(Object.assign(new Error('aborted'), { name: 'AbortError' }))
+        : Promise.resolve(streamResponse([delta('a'), done()])),
+    )
+    const out: string[] = []
+    for await (const chunk of ai.chatStream([{ role: 'user', content: 'hi' }], { signal: ac.signal })) {
+      out.push(chunk.delta)
+    }
+    expect(out).toEqual([])
+  })
+
+  it('refresh proactif si token expiré (refresh AVANT ouverture du flux)', async () => {
+    const store = new BaseAuthStore()
+    store.save(expiredJwt(), 'rt', fakeUser())
+    const { ai, calls } = make((url) => {
+      if (url.includes('/v1/auth/')) return new Response(JSON.stringify({ access_token: validJwt(), refresh_token: 'rt2', token_type: 'bearer', expires_in: 3600, user: fakeUser() }), { status: 200, headers: { 'Content-Type': 'application/json' } })
+      return streamResponse([done()])
+    }, store)
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    for await (const _ of ai.chatStream([{ role: 'user', content: 'hi' }])) { /* drain */ }
+    expect(calls[0]!.url).toContain('/v1/auth/p/refresh')
+    expect(calls[1]!.url).toContain('/chat/stream')
+  })
+
+  it('chat() (JSON) reste inchangé', async () => {
+    const { ai } = make(() => new Response(JSON.stringify({ data: { model: 'm', content: 'hi' } }), { status: 200, headers: { 'Content-Type': 'application/json' } }))
+    const { data, error } = await ai.chat([{ role: 'user', content: 'hi' }])
+    expect(error).toBeNull()
+    expect(data).toEqual({ model: 'm', content: 'hi' })
+  })
+})

package/packages/ai/tests/rag-namespaces.test.ts

@@ -0,0 +1,54 @@
+import { describe, it, expect } from 'vitest'
+import { AiService } from '../src/AiService'
+import { BaseAuthStore } from '@aurabase/core'
+import type { AuraClientLike } from '@aurabase/core'
+
+function make(responder: (url: string, init: RequestInit) => Response) {
+  const calls: Array<{ url: string; method: string }> = []
+  const client: AuraClientLike = {
+    baseUrl: 'http://x', projectId: 'p', apiKey: 'k', authStore: new BaseAuthStore(),
+    fetchFn: (async (url: string, init: RequestInit) => {
+      calls.push({ url: String(url), method: String(init.method) })
+      return responder(String(url), init)
+    }) as unknown as typeof globalThis.fetch,
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    auth: { refreshSession: async () => ({ data: null, error: null }) as any },
+  }
+  return { ai: new AiService(client), calls }
+}
+const json = (o: unknown, s = 200) => new Response(JSON.stringify(o), { status: s, headers: { 'Content-Type': 'application/json' } })
+
+describe('ai RAG — CRUD namespaces', () => {
+  it('listNamespaces → GET /rag/namespaces, dé-wrappe la liste', async () => {
+    const { ai, calls } = make(() => json({ data: ['ns_a', 'ns_b'] }))
+    const { data, error } = await ai.listNamespaces()
+    expect(error).toBeNull()
+    expect(data).toEqual(['ns_a', 'ns_b'])
+    expect(calls[0]).toEqual({ url: 'http://x/v1/ai/p/rag/namespaces', method: 'GET' })
+  })
+
+  it('deleteNamespace → DELETE /rag/{ns} (encodé), dé-wrappe { deleted }', async () => {
+    const { ai, calls } = make(() => json({ data: { deleted: 3 } }))
+    const { data, error } = await ai.deleteNamespace('ns test/x')
+    expect(error).toBeNull()
+    expect(data).toEqual({ deleted: 3 })
+    expect(calls[0]!.method).toBe('DELETE')
+    expect(calls[0]!.url).toBe('http://x/v1/ai/p/rag/ns%20test%2Fx')
+  })
+
+  it('reindexNamespace → POST /rag/{ns}/reindex (encodé), dé-wrappe ReindexResponse', async () => {
+    const { ai, calls } = make(() => json({ data: { reindexed: 42, embedding_model: 'text-embedding-3-small' } }))
+    const { data, error } = await ai.reindexNamespace('ns#1')
+    expect(error).toBeNull()
+    expect(data).toEqual({ reindexed: 42, embedding_model: 'text-embedding-3-small' })
+    expect(calls[0]!.method).toBe('POST')
+    expect(calls[0]!.url).toBe('http://x/v1/ai/p/rag/ns%231/reindex')
+  })
+
+  it('propage une erreur HTTP (status)', async () => {
+    const { ai } = make(() => json({ error: { code: 'not_found', message: 'x' } }, 404))
+    const { data, error } = await ai.deleteNamespace('missing')
+    expect(data).toBeNull()
+    expect(error?.status).toBe(404)
+  })
+})