> Discover all available pages from the documentation index: https://mastra.zisheng.pro/fr/llms.txt

# Utilitaires des fils clonés

La classe Memory fournit des méthodes utilitaires pour travailler avec des fils clonés. Ces méthodes vous permettent de vérifier l'état d'un clone, de récupérer ses métadonnées, de parcourir les relations de clonage et de suivre l'historique des clones.

## `isClone()`

Vérifie si un fil est le clone d'un autre fil.

### Utilisation

```typescript
const isClonedThread = memory.isClone(thread)
```

### Paramètres

**thread** (`StorageThreadType`): Objet de fil à vérifier.

### Exemple

```typescript
const thread = await memory.getThreadById({ threadId: 'some-thread-id' })

if (memory.isClone(thread)) {
  console.log('This thread was cloned from another thread')
} else {
  console.log('This is an original thread')
}
```

## `getCloneMetadata()`

Récupère les métadonnées de clonage d'un fil si elles existent.

### Utilisation

```typescript
const metadata = memory.getCloneMetadata(thread)
```

### Paramètres

**thread** (`StorageThreadType`): Objet de fil dont extraire les métadonnées de clonage.

### Exemple

```typescript
const thread = await memory.getThreadById({ threadId: 'cloned-thread-id' })
const cloneInfo = memory.getCloneMetadata(thread)

if (cloneInfo) {
  console.log(`Cloned from: ${cloneInfo.sourceThreadId}`)
  console.log(`Cloned at: ${cloneInfo.clonedAt}`)
}
```

## `getSourceThread()`

Récupère le fil source d'origine à partir duquel un fil cloné a été créé.

### Utilisation

```typescript
const sourceThread = await memory.getSourceThread(threadId)
```

### Paramètres

**threadId** (`string`): Identifiant du fil cloné.

### Exemple

```typescript
const sourceThread = await memory.getSourceThread('cloned-thread-id')

if (sourceThread) {
  console.log(`Original thread title: ${sourceThread.title}`)
  console.log(`Original thread created: ${sourceThread.createdAt}`)
}
```

## `listClones()`

Répertorie tous les fils clonés à partir d'un fil source donné.

### Utilisation

```typescript
const clones = await memory.listClones(sourceThreadId)
```

### Paramètres

**sourceThreadId** (`string`): Identifiant du fil source dont il faut rechercher les clones.

### Exemple

```typescript
const clones = await memory.listClones('original-thread-id')

console.log(`Found ${clones.length} clones`)
for (const clone of clones) {
  console.log(`- ${clone.id}: ${clone.title}`)
}
```

## `getCloneHistory()`

Récupère la chaîne complète de l'historique de clonage d'un fil, en remontant jusqu'à l'original.

### Utilisation

```typescript
const history = await memory.getCloneHistory(threadId)
```

### Paramètres

**threadId** (`string`): Identifiant du fil dont il faut récupérer l'historique de clonage.

### Exemple

```typescript
// If thread-c was cloned from thread-b, which was cloned from thread-a
const history = await memory.getCloneHistory('thread-c')

// history = [thread-a, thread-b, thread-c]
console.log(`Clone depth: ${history.length - 1}`)
console.log(`Original thread: ${history[0].id}`)
console.log(`Current thread: ${history[history.length - 1].id}`)

// Display the clone chain
for (let i = 0; i < history.length; i++) {
  const prefix = i === 0 ? 'Original' : `Clone ${i}`
  console.log(`${prefix}: ${history[i].title}`)
}
```

## Exemple complet

```typescript
import { mastra } from './mastra'

async function manageClones() {
  const agent = mastra.getAgent('agent')
  const memory = await agent.getMemory()

  // Create an original conversation
  const originalThread = await memory.createThread({
    resourceId: 'user-123',
    title: 'Original Conversation',
  })

  // Have a conversation...
  await agent.generate("Hello! Let's discuss project options.", {
    memory: {
      thread: originalThread.id,
      resource: 'user-123',
    },
  })

  // Create multiple branches (clones) to explore different paths
  const { thread: optionA } = await memory.cloneThread({
    sourceThreadId: originalThread.id,
    title: 'Option A - Conservative Approach',
  })

  const { thread: optionB } = await memory.cloneThread({
    sourceThreadId: originalThread.id,
    title: 'Option B - Aggressive Approach',
  })

  // Check clone status
  console.log(memory.isClone(originalThread)) // false
  console.log(memory.isClone(optionA)) // true
  console.log(memory.isClone(optionB)) // true

  // Get clone metadata
  const metadataA = memory.getCloneMetadata(optionA)
  console.log(metadataA?.sourceThreadId) // originalThread.id

  // List all clones of the original
  const allClones = await memory.listClones(originalThread.id)
  console.log(`Total alternatives: ${allClones.length}`) // 2

  // Get source thread from a clone
  const source = await memory.getSourceThread(optionA.id)
  console.log(source?.id === originalThread.id) // true

  // Create a deeper clone chain
  const { thread: optionA2 } = await memory.cloneThread({
    sourceThreadId: optionA.id,
    title: 'Option A - Variant 2',
  })

  // Get the full history
  const history = await memory.getCloneHistory(optionA2.id)
  // history = [originalThread, optionA, optionA2]
  console.log(`Clone depth: ${history.length - 1}`) // 2
}
```