@boostecom/provider 0.0.1

package/docs/content/guide.mdx

@@ -0,0 +1,516 @@
+---
+title: Guide d'utilisation
+description: Guide complet pour utiliser le provider Claude Code dans vos applications
+---
+
+# Guide d'utilisation
+
+Ce guide vous accompagne à travers les fonctionnalités essentielles du provider Claude Code, de l'utilisation basique aux patterns avancés.
+
+## Utilisation basique
+
+### Génération de texte simple
+
+La méthode la plus simple pour obtenir une réponse de Claude :
+
+```typescript
+import { generateText } from 'ai';
+import { claudeCode } from '@boostecom/provider';
+
+const { text } = await generateText({
+  model: claudeCode('haiku'),
+  prompt: 'Explique la programmation asynchrone en JavaScript',
+});
+
+console.log(text);
+```
+
+### Streaming en temps réel
+
+Pour des interfaces utilisateur réactives avec affichage progressif :
+
+```typescript
+import { streamText } from 'ai';
+import { claudeCode } from '@boostecom/provider';
+
+const result = streamText({
+  model: claudeCode('sonnet'),
+  prompt: 'Écris une courte histoire sur un robot',
+});
+
+// Afficher chaque fragment au fur et à mesure
+for await (const chunk of result.textStream) {
+  process.stdout.write(chunk);
+}
+
+console.log('\n✅ Terminé');
+```
+
+<Note type="info">
+  Utilisez le streaming pour améliorer l'expérience utilisateur - les utilisateurs voient la réponse se construire en temps réel plutôt que d'attendre la réponse complète.
+</Note>
+
+## Conversations multi-tours
+
+Maintenez le contexte à travers plusieurs échanges :
+
+```typescript
+import { generateText } from 'ai';
+import { claudeCode } from '@boostecom/provider';
+import type { CoreMessage } from 'ai';
+
+// Historique de la conversation
+const messages: CoreMessage[] = [
+  { role: 'user', content: 'Bonjour, je m\'appelle Alice' },
+  { role: 'assistant', content: 'Ravi de vous rencontrer, Alice !' },
+  { role: 'user', content: 'Quel est mon prénom ?' },
+];
+
+const { text } = await generateText({
+  model: claudeCode('haiku'),
+  messages, // Passer l'historique complet
+});
+
+console.log(text); // "Votre prénom est Alice."
+```
+
+### Pattern chatbot complet
+
+```typescript
+import { streamText } from 'ai';
+import { claudeCode } from '@boostecom/provider';
+import * as readline from 'readline';
+import type { CoreMessage } from 'ai';
+
+const messages: CoreMessage[] = [];
+const rl = readline.createInterface({
+  input: process.stdin,
+  output: process.stdout,
+});
+
+async function chat() {
+  rl.question('Vous: ', async (userInput) => {
+    if (userInput.toLowerCase() === 'exit') {
+      rl.close();
+      return;
+    }
+
+    // Ajouter le message utilisateur
+    messages.push({ role: 'user', content: userInput });
+
+    // Générer la réponse
+    const result = streamText({
+      model: claudeCode('sonnet'),
+      messages,
+    });
+
+    process.stdout.write('Assistant: ');
+    let assistantResponse = '';
+
+    for await (const chunk of result.textStream) {
+      process.stdout.write(chunk);
+      assistantResponse += chunk;
+    }
+
+    console.log('\n');
+
+    // Ajouter la réponse à l'historique
+    messages.push({ role: 'assistant', content: assistantResponse });
+
+    // Continuer la conversation
+    chat();
+  });
+}
+
+console.log('Chatbot démarré (tapez "exit" pour quitter)\n');
+chat();
+```
+
+## Structured Outputs (Génération d'objets)
+
+Générez des données structurées avec validation de schéma automatique :
+
+### Objet simple
+
+```typescript
+import { generateObject } from 'ai';
+import { claudeCode } from '@boostecom/provider';
+import { z } from 'zod';
+
+const result = await generateObject({
+  model: claudeCode('haiku'),
+  schema: z.object({
+    nom: z.string(),
+    age: z.number(),
+    email: z.string().describe('Adresse email (ex: user@example.com)'),
+  }),
+  prompt: 'Génère un profil utilisateur pour un développeur',
+});
+
+console.log(result.object);
+// { nom: "Alex Chen", age: 28, email: "alex@example.com" }
+```
+
+<Note type="warning">
+  **Limitation importante** : Évitez `.email()`, `.url()`, `.uuid()`, `.datetime()` et les regex complexes avec lookaheads. Ces contraintes peuvent faire échouer silencieusement la génération structurée. Utilisez `.describe()` avec des indices de format et validez côté client.
+</Note>
+
+### Objet avec contraintes
+
+```typescript
+import { generateObject } from 'ai';
+import { claudeCode } from '@boostecom/provider';
+import { z } from 'zod';
+
+const result = await generateObject({
+  model: claudeCode('sonnet'),
+  schema: z.object({
+    nom: z.string().min(2).max(50),
+    age: z.number().int().min(18).max(120),
+    role: z.enum(['admin', 'user', 'guest']),
+    tags: z.array(z.string()).min(1).max(5),
+    score: z.number().min(0).max(100).multipleOf(5),
+  }),
+  prompt: 'Génère un utilisateur avec un score multiple de 5',
+});
+
+console.log(result.object);
+```
+
+### Streaming d'objets
+
+Pour afficher progressivement un objet structuré :
+
+```typescript
+import { streamObject } from 'ai';
+import { claudeCode } from '@boostecom/provider';
+import { z } from 'zod';
+
+const result = streamObject({
+  model: claudeCode('sonnet'),
+  schema: z.object({
+    recette: z.object({
+      titre: z.string(),
+      ingredients: z.array(z.string()),
+      etapes: z.array(z.string()),
+    }),
+  }),
+  prompt: 'Génère une recette de cookies',
+});
+
+// Afficher les parties au fur et à mesure
+for await (const partialObject of result.partialObjectStream) {
+  console.clear();
+  console.log('📊 Objet partiel:', JSON.stringify(partialObject, null, 2));
+}
+
+// Objet final complet
+const finalObject = await result.object;
+console.log('✅ Objet final:', finalObject);
+```
+
+## Entrées multimodales (Images)
+
+Analysez des images avec Claude :
+
+```typescript
+import { streamText } from 'ai';
+import { claudeCode } from '@boostecom/provider';
+import { readFileSync } from 'fs';
+
+// Charger l'image en base64
+const imageBuffer = readFileSync('/chemin/vers/image.png');
+const base64Image = imageBuffer.toString('base64');
+const dataUrl = `data:image/png;base64,${base64Image}`;
+
+const result = streamText({
+  model: claudeCode('sonnet', {
+    streamingInput: 'always', // REQUIS pour les images
+  }),
+  messages: [
+    {
+      role: 'user',
+      content: [
+        { type: 'text', text: 'Que vois-tu dans cette image ?' },
+        { type: 'image', image: dataUrl },
+      ],
+    },
+  ],
+});
+
+for await (const chunk of result.textStream) {
+  process.stdout.write(chunk);
+}
+```
+
+<Note type="info">
+  **Prérequis** : `streamingInput: 'always'` est obligatoire pour envoyer des images. Les URLs d'images distantes ne sont pas supportées - utilisez des data URLs en base64.
+</Note>
+
+## Configuration et personnalisation
+
+### Choisir le bon modèle
+
+```typescript
+// Haiku - Rapide et économique (idéal pour prototypage, tâches simples)
+const fast = claudeCode('haiku');
+
+// Sonnet - Équilibré (recommandé pour la plupart des cas)
+const balanced = claudeCode('sonnet');
+
+// Opus - Le plus capable (tâches complexes, raisonnement avancé)
+const powerful = claudeCode('opus');
+```
+
+### System prompt personnalisé
+
+```typescript
+import { streamText } from 'ai';
+import { claudeCode } from '@boostecom/provider';
+
+const model = claudeCode('sonnet', {
+  systemPrompt: 'Tu es un assistant spécialisé en développement web. ' +
+                'Réponds toujours avec des exemples de code pratiques.',
+});
+
+const result = await streamText({
+  model,
+  prompt: 'Comment créer un serveur Express ?',
+});
+```
+
+### Répertoire de travail
+
+```typescript
+const model = claudeCode('sonnet', {
+  cwd: '/chemin/vers/projet', // Claude travaillera dans ce répertoire
+});
+```
+
+### Limite de tours de conversation
+
+```typescript
+const model = claudeCode('sonnet', {
+  maxTurns: 5, // Limiter à 5 tours de conversation
+});
+```
+
+## Gestion des outils
+
+Claude Code a accès à des outils intégrés (Read, Write, Bash, etc.). Vous pouvez contrôler leur accès :
+
+### Autoriser des outils spécifiques
+
+```typescript
+const model = claudeCode('sonnet', {
+  allowedTools: ['Read', 'LS'], // Seulement lecture et listage
+});
+
+const result = await streamText({
+  model,
+  prompt: 'Liste les fichiers de ce répertoire',
+});
+```
+
+### Interdire des outils dangereux
+
+```typescript
+const model = claudeCode('sonnet', {
+  disallowedTools: [
+    'Write',
+    'Edit', 
+    'Bash(rm:*)', // Interdire les commandes rm
+  ],
+});
+```
+
+### Observer l'utilisation des outils
+
+```typescript
+import { streamText } from 'ai';
+import { claudeCode } from '@boostecom/provider';
+
+const result = streamText({
+  model: claudeCode('sonnet', {
+    allowedTools: ['Read', 'Bash'],
+  }),
+  prompt: 'Lis le package.json et dis-moi la version',
+});
+
+for await (const part of result.fullStream) {
+  if (part.type === 'tool-call') {
+    console.log('🔧 Outil appelé:', part.toolName);
+    console.log('📥 Arguments:', part.args);
+  } else if (part.type === 'tool-result') {
+    console.log('📤 Résultat:', part.result);
+  } else if (part.type === 'text-delta') {
+    process.stdout.write(part.textDelta);
+  }
+}
+```
+
+## Gestion des erreurs
+
+### Pattern de gestion d'erreur robuste
+
+```typescript
+import { generateText } from 'ai';
+import { claudeCode } from '@boostecom/provider';
+
+async function generateSafely(prompt: string) {
+  try {
+    const { text } = await generateText({
+      model: claudeCode('haiku'),
+      prompt,
+    });
+    return { success: true, text };
+  } catch (error: any) {
+    // Erreur d'authentification
+    if (error.message?.includes('authentication')) {
+      return { 
+        success: false, 
+        error: 'Non authentifié. Exécutez: claude login' 
+      };
+    }
+    
+    // CLI non trouvé
+    if (error.code === 'ENOENT') {
+      return { 
+        success: false, 
+        error: 'CLI Claude Code non trouvé. Installez-le avec: npm install -g @anthropic-ai/claude-code' 
+      };
+    }
+    
+    // Erreur générique
+    return { 
+      success: false, 
+      error: error.message || 'Erreur inconnue' 
+    };
+  }
+}
+
+// Utilisation
+const result = await generateSafely('Bonjour');
+if (result.success) {
+  console.log(result.text);
+} else {
+  console.error('❌', result.error);
+}
+```
+
+## Timeouts et annulation
+
+### Timeout personnalisé
+
+```typescript
+const controller = new AbortController();
+const timeoutId = setTimeout(() => controller.abort(), 30000); // 30 secondes
+
+try {
+  const { text } = await generateText({
+    model: claudeCode('opus'),
+    prompt: 'Analyse complexe...',
+    abortSignal: controller.signal,
+  });
+  clearTimeout(timeoutId);
+  console.log(text);
+} catch (error: any) {
+  if (error.name === 'AbortError') {
+    console.error('⏱️ Timeout dépassé');
+  }
+}
+```
+
+### Annulation utilisateur
+
+```typescript
+import * as readline from 'readline';
+
+const controller = new AbortController();
+
+// Permettre l'annulation par Ctrl+C
+readline.emitKeypressEvents(process.stdin);
+if (process.stdin.isTTY) {
+  process.stdin.setRawMode(true);
+}
+
+process.stdin.on('keypress', (str, key) => {
+  if (key.ctrl && key.name === 'c') {
+    console.log('\n\n🛑 Annulation...');
+    controller.abort();
+    process.exit();
+  }
+});
+
+const result = streamText({
+  model: claudeCode('opus'),
+  prompt: 'Tâche longue...',
+  abortSignal: controller.signal,
+});
+
+console.log('⏳ Génération en cours (Ctrl+C pour annuler)...\n');
+
+for await (const chunk of result.textStream) {
+  process.stdout.write(chunk);
+}
+```
+
+## Logging et debugging
+
+### Mode verbose
+
+```typescript
+const model = claudeCode('sonnet', {
+  verbose: true, // Activer les logs détaillés
+});
+```
+
+### Logger personnalisé
+
+```typescript
+import type { Logger } from '@boostecom/provider';
+
+const customLogger: Logger = {
+  debug: (msg) => console.log(`[DEBUG] ${msg}`),
+  info: (msg) => console.log(`[INFO] ${msg}`),
+  warn: (msg) => console.warn(`[WARN] ${msg}`),
+  error: (msg) => console.error(`[ERROR] ${msg}`),
+};
+
+const model = claudeCode('sonnet', {
+  verbose: true,
+  logger: customLogger,
+});
+```
+
+### Désactiver complètement les logs
+
+```typescript
+const model = claudeCode('sonnet', {
+  logger: false, // Aucun log
+});
+```
+
+## Métadonnées et usage
+
+Accédez aux informations de coût et d'utilisation :
+
+```typescript
+const { text, usage, providerMetadata } = await generateText({
+  model: claudeCode('sonnet'),
+  prompt: 'Bonjour',
+});
+
+console.log('Tokens utilisés:', usage);
+// { promptTokens: 10, completionTokens: 20, totalTokens: 30 }
+
+console.log('Métadonnées provider:', providerMetadata);
+// { 'claude-code': { cost: 0.0015, duration: 2300, ... } }
+```
+
+## Prochaines étapes
+
+- [API Reference](/docs/api) - Documentation complète de toutes les options
+- [Exemples avancés](/docs/examples) - Patterns d'utilisation avancés
+- [Skills](/docs/skills) - Créer et utiliser des compétences personnalisées
+- [Agent Teams](/docs/agent-teams) - Créer des équipes d'agents spécialisés

package/docs/content/index.mdx

@@ -0,0 +1,99 @@
+---
+title: Introduction
+description: Provider non officiel pour utiliser Claude via le Vercel AI SDK avec le Claude Agent SDK
+---
+
+# AI SDK Provider for Claude Code
+
+<Note type="info">
+  **Version actuelle** : 3.x.x supporte AI SDK v6 stable avec le Claude Agent SDK
+</Note>
+
+**@boostecom/provider** est un provider **non officiel** qui vous permet d'utiliser Claude Code dans le [Vercel AI SDK](https://sdk.vercel.ai/docs) via le CLI `@anthropic-ai/claude-agent-sdk`. Contrairement à l'API Anthropic, ce provider fonctionne avec votre **abonnement Claude Pro ou Max** — aucune clé API n'est nécessaire.
+
+## Aperçu rapide
+
+Ce provider fait le pont entre le Vercel AI SDK et le CLI Claude Code, vous permettant d'intégrer les capacités avancées de Claude Code dans vos applications avec :
+
+- 🚀 Compatibilité complète avec le Vercel AI SDK
+- 🔄 Support du streaming en temps réel
+- 💬 Conversations multi-tours avec gestion de sessions
+- 🎯 Structured outputs natifs avec validation de schéma
+- 🛑 Support des signaux d'annulation (AbortSignal)
+- 🔧 Gestion avancée des outils (MCP servers, permissions)
+- 🧩 Callbacks et hooks de lifecycle personnalisables
+
+## Compatibilité des versions
+
+| Version Provider | AI SDK | SDK Sous-jacent | Tag NPM | Statut | Branch |
+|-----------------|--------|-----------------|---------|--------|--------|
+| 3.x.x | v6 | `@anthropic-ai/claude-agent-sdk` | `latest` | Stable | `main` |
+| 2.x.x | v5 | `@anthropic-ai/claude-agent-sdk` | `ai-sdk-v5` | Stable | `ai-sdk-v5` |
+| 1.x.x | v5 | `@anthropic-ai/claude-code` (legacy) | `v1-claude-code-sdk` | Legacy | `v1` |
+| 0.x.x | v4 | `@anthropic-ai/claude-code` (legacy) | `ai-sdk-v4` | Legacy | `ai-sdk-v4` |
+
+## Installation rapide
+
+```bash
+# 1. Installer et authentifier le CLI
+npm install -g @anthropic-ai/claude-code
+claude login
+
+# 2. Installer le provider (AI SDK v6)
+npm install @boostecom/provider ai@^6.0.0 zod@^4.0.0
+```
+
+<Note type="warning">
+  **Zod 4 requis** : À partir de v3.2.0, ce package nécessite Zod 4 en raison du SDK sous-jacent.
+</Note>
+
+## Exemple basique
+
+```typescript
+import { streamText } from 'ai';
+import { claudeCode } from '@boostecom/provider';
+
+const result = await streamText({
+  model: claudeCode('haiku'),
+  prompt: 'Bonjour, Claude!',
+});
+
+const text = await result.text;
+console.log(text);
+```
+
+## Modèles disponibles
+
+- **`opus`** - Claude Opus (le plus capable)
+- **`sonnet`** - Claude Sonnet (performance équilibrée)  
+- **`haiku`** - Claude Haiku (le plus rapide et économique)
+
+Vous pouvez également utiliser les identifiants complets des modèles directement (ex: `claude-opus-4-5`, `claude-sonnet-4-5-20250514`).
+
+## Disclaimer
+
+<Note type="danger">
+  **Ce provider est non officiel** et n'est ni affilié ni approuvé par Anthropic ou Vercel. En utilisant ce provider :
+
+  - Vous utilisez Claude Code via votre abonnement Pro/Max — ce provider ne passe pas par l'API Anthropic
+  - Vous comprenez que vos données transitent par le CLI Claude Code vers les serveurs d'Anthropic
+  - Vous acceptez de respecter les [Conditions d'utilisation d'Anthropic](https://www.anthropic.com/legal/consumer-terms)
+  - Vous reconnaissez que ce logiciel est fourni "tel quel" sans garanties d'aucune sorte
+</Note>
+
+## Prochaines étapes
+
+<CardGroup cols={2}>
+  <Card title="Installation" href="/docs/installation" icon="download">
+    Guide d'installation détaillé et configuration
+  </Card>
+  <Card title="Guide d'utilisation" href="/docs/guide" icon="book">
+    Exemples complets et patterns d'utilisation
+  </Card>
+  <Card title="API Reference" href="/docs/api" icon="code">
+    Documentation complète de l'API
+  </Card>
+  <Card title="Exemples" href="/docs/examples" icon="lightbulb">
+    Exemples pratiques pour tous les cas d'usage
+  </Card>
+</CardGroup>