Dateiänderungen mit Checkpointing rückgängig machen

Verfolgen Sie Dateiänderungen während Agent-Sitzungen und stellen Sie Dateien in jeden vorherigen Zustand wieder her

File Checkpointing verfolgt Dateiänderungen, die während einer Agent-Sitzung durch die Tools Write, Edit und NotebookEdit vorgenommen werden, und ermöglicht es Ihnen, Dateien in jeden vorherigen Zustand zurückzusetzen. Um zu sehen, wie ein Rewind eine Datei wiederherstellt, springen Sie zum interaktiven Beispiel.

[!WARNING]

rewindFiles() macht nicht rückgängig, was sed -i oder ein anderer Bash-Befehl an einer Datei geändert hat, es sei denn, ein Tool wie Write oder Edit hatte diese Datei in der Hauptkonversation geändert. Änderungen von Subagenten werden nicht verfolgt, Änderungen eines im Vordergrund ausgeführten Skills mit context: fork dagegen schon.

Wie Checkpointing funktioniert

Wenn Sie File Checkpointing aktivieren, erstellt das SDK Sicherungen von Dateien, bevor diese durch die Tools Write, Edit oder NotebookEdit geändert werden. Benutzermeldungen im Response-Stream enthalten eine Checkpoint-UUID, die Sie als Wiederherstellungspunkt verwenden können.

[!NOTE]

File Rewinding stellt Dateien auf der Festplatte in einen vorherigen Zustand wieder her. Es setzt das Gespräch selbst nicht zurück. Der Gesprächsverlauf und der Kontext bleiben nach dem Aufrufen von rewindFiles() (TypeScript) oder rewind_files() (Python) intakt.

Wenn Sie zu einem Checkpoint zurückspulen, löscht Claude Code die Dateien, die es erstellt hat, und stellt die Dateien, die es geändert hat, auf ihren Inhalt an diesem Punkt wieder her. Claude Code überspringt einen verfolgten Pfad, der ein Symlink, Hard Link oder eine andere nicht-reguläre Datei ist. Es überspringt auch eine verfolgte Datei, deren übergeordnetes Verzeichnis nicht mehr zu seinem Checkpoint-Zeit-Speicherort aufgelöst wird, oder deren Sicherung es nicht sicher lesen kann. RewindFilesResult zählt jeden übersprungenen Pfad in seinem skippedLinks-Feld. Das Überspringen erfordert Claude Code v2.1.216 oder später; vor v2.1.216 schrieb und löschte ein Rewind durch Links bei verfolgten Pfaden.

Checkpointing implementieren

Um File Checkpointing zu verwenden, aktivieren Sie es in Ihren Optionen, erfassen Sie Checkpoint-UUIDs aus dem Response-Stream und rufen Sie rewindFiles() (TypeScript) oder rewind_files() (Python) auf, wenn Sie Dateien wiederherstellen müssen.

Die Beispiele in diesem Abschnitt verwenden die Eingabeaufforderung „Refactor the authentication module“. Führen Sie sie in einem Projekt aus, das ein Authentifizierungsmodul enthält, oder ändern Sie die Eingabeaufforderung, um Dateien zu benennen, die in Ihrem Projekt vorhanden sind, damit Sie Dateiänderungen beobachten und sehen können, wie das Zurückspulen sie wiederherstellt.

Dieses Beispiel aktiviert Checkpointing, erfasst die Checkpoint-UUID und Session-ID aus dem Response-Stream und setzt die Sitzung später fort, um Dateien zurückzuspulen. Die nummerierten Kommentare des Beispiels entsprechen den folgenden Schritten.

import asyncio
from claude_agent_sdk import (
    ClaudeSDKClient,
    ClaudeAgentOptions,
    UserMessage,
    ResultMessage,
)


async def main():
    # Step 1: Enable checkpointing
    options = ClaudeAgentOptions(
        enable_file_checkpointing=True,
        permission_mode="acceptEdits",  # Auto-accept file edits without prompting
        extra_args={
            "replay-user-messages": None
        },  # Required to receive checkpoint UUIDs in the response stream
    )

    checkpoint_id = None
    session_id = None

    # Run the query and capture checkpoint UUID and session ID
    async with ClaudeSDKClient(options) as client:
        await client.query("Refactor the authentication module")

        # Step 2: Capture checkpoint UUID from the first user message
        async for message in client.receive_response():
            if isinstance(message, UserMessage) and message.uuid and not checkpoint_id:
                checkpoint_id = message.uuid
            if isinstance(message, ResultMessage) and not session_id:
                session_id = message.session_id

    # Step 3: Later, rewind by resuming the session with an empty prompt
    if checkpoint_id and session_id:
        async with ClaudeSDKClient(
            ClaudeAgentOptions(enable_file_checkpointing=True, resume=session_id)
        ) as client:
            await client.query("")  # Empty prompt to open the connection
            async for message in client.receive_response():
                await client.rewind_files(checkpoint_id)
                break
        print(f"Rewound to checkpoint: {checkpoint_id}")


asyncio.run(main())

import { query } from "@anthropic-ai/claude-agent-sdk";

async function main() {
  // Step 1: Enable checkpointing
  const opts = {
    enableFileCheckpointing: true,
    permissionMode: "acceptEdits" as const, // Auto-accept file edits without prompting
    extraArgs: { "replay-user-messages": null } // Required to receive checkpoint UUIDs in the response stream
  };

  const response = query({
    prompt: "Refactor the authentication module",
    options: opts
  });

  let checkpointId: string | undefined;
  let sessionId: string | undefined;

  // Step 2: Capture checkpoint UUID from the first user message
  try {
    for await (const message of response) {
      if (message.type === "user" && message.uuid && !checkpointId) {
        checkpointId = message.uuid;
      }
      if ("session_id" in message && !sessionId) {
        sessionId = message.session_id;
      }
    }
  } catch (error) {
    // A single-shot query() throws after yielding an error result. If the
    // failure was an error result, sessionId and checkpointId were already
    // captured by the loop above; connection or process failures yield no
    // result message.
    console.error(`Session ended with an error: ${error}`);
  }

  // Step 3: Later, rewind by resuming the session with an empty prompt
  if (checkpointId && sessionId) {
    const rewindQuery = query({
      prompt: "", // Empty prompt to open the connection
      options: { ...opts, resume: sessionId }
    });

    for await (const msg of rewindQuery) {
      await rewindQuery.rewindFiles(checkpointId);
      break;
    }
    console.log(`Rewound to checkpoint: ${checkpointId}`);
  }
}

main();

1. Checkpointing aktivieren

Konfigurieren Sie Ihre SDK-Optionen, um Checkpointing zu aktivieren und Checkpoint-UUIDs zu erhalten:

Das führende Beispiel unter Checkpointing implementieren setzt auch den Berechtigungsmodus auf acceptEdits, was die Dateibearbeitungen des Agenten ohne Eingabeaufforderung genehmigt. Weitere Informationen finden Sie unter Berechtigungsmodi.

2. Checkpoint-UUID und Session-ID erfassen

Mit der oben gezeigten Option replay-user-messages hat jede Benutzermeldung im Response-Stream eine UUID, die als Checkpoint dient.

Für die meisten Anwendungsfälle erfassen Sie die UUID der ersten Benutzermeldung (message.uuid); das Zurückspulen zu ihr stellt die verfolgten Dateien in ihren ursprünglichen Zustand wieder her. Um mehrere Checkpoints zu speichern und zu Zwischenzuständen zurückzuspulen, siehe Mehrere Wiederherstellungspunkte.

Das Erfassen der Session-ID (message.session_id) ist optional; Sie benötigen sie nur, wenn Sie später zurückspulen möchten, nachdem der Stream abgeschlossen ist. Wenn Sie rewindFiles() sofort aufrufen, während Sie noch Meldungen verarbeiten (wie das Beispiel in Checkpoint vor riskanten Operationen zeigt), können Sie das Erfassen der Session-ID überspringen.

3. Dateien zurückspulen

Um nach Abschluss des Streams zurückzuspulen, setzen Sie die Sitzung mit einer leeren Eingabeaufforderung fort und rufen Sie rewind_files() (Python) oder rewindFiles() (TypeScript) mit Ihrer Checkpoint-UUID auf. Aktivieren Sie Checkpointing auch in den Optionen der fortgesetzten Sitzung und rufen Sie rewind aus der Response-Schleife auf. Sie können auch während des Streams zurückspulen. Siehe Checkpoint vor riskanten Operationen für dieses Muster.

Wenn Sie die Session-ID und Checkpoint-ID erfassen, können Sie auch von der CLI aus zurückspulen. Dieser Befehl erfordert die ausführbare Datei claude, die von der Installation von Claude Code stammt. Das SDK aktiviert Checkpointing für Sie, aber wenn Sie claude -p direkt ausführen, müssen Sie die Umgebungsvariable CLAUDE_CODE_ENABLE_SDK_FILE_CHECKPOINTING setzen:

CLAUDE_CODE_ENABLE_SDK_FILE_CHECKPOINTING=true claude -p --resume <session-id> --rewind-files <checkpoint-uuid>

Das Flag --rewind-files wird nicht in der Ausgabe von claude --help angezeigt, aber die CLI akzeptiert es wie gezeigt. Wenn das Zurückspulen erfolgreich ist, gibt der Befehl Files rewound to state at message <checkpoint-uuid> aus und wird beendet, ohne eine Eingabeaufforderung zu senden.

Häufige Muster

Diese Muster zeigen verschiedene Möglichkeiten, Checkpoint-UUIDs je nach Ihrem Anwendungsfall zu erfassen und zu verwenden.

Checkpoint vor riskanten Operationen

Dieses Muster behält nur die neueste Checkpoint-UUID, aktualisiert sie vor jedem Agent-Turn. Wenn während der Verarbeitung etwas schief geht, können Sie sofort zum letzten sicheren Zustand zurückspulen und die Schleife unterbrechen.

Ersetzen Sie vor dem Ausführen dieses Beispiels your_revert_condition (Python) oder yourRevertCondition (TypeScript) durch Ihre eigene Überprüfung, z. B. Fehlererkennung oder ein Validierungsfehler; der Platzhalter ist im Beispiel nicht definiert.

import asyncio
from claude_agent_sdk import ClaudeSDKClient, ClaudeAgentOptions, UserMessage


async def main():
    options = ClaudeAgentOptions(
        enable_file_checkpointing=True,
        permission_mode="acceptEdits",
        extra_args={"replay-user-messages": None},
    )

    safe_checkpoint = None

    async with ClaudeSDKClient(options) as client:
        await client.query("Refactor the authentication module")

        async for message in client.receive_response():
            # Update checkpoint before each agent turn starts
            # This overwrites the previous checkpoint. Only keep the latest
            if isinstance(message, UserMessage) and message.uuid:
                safe_checkpoint = message.uuid

            # Decide when to revert based on your own logic
            # For example: error detection, validation failure, or user input
            if your_revert_condition and safe_checkpoint:
                await client.rewind_files(safe_checkpoint)
                # Exit the loop after rewinding, files are restored
                break


asyncio.run(main())

import { query } from "@anthropic-ai/claude-agent-sdk";

async function main() {
  const response = query({
    prompt: "Refactor the authentication module",
    options: {
      enableFileCheckpointing: true,
      permissionMode: "acceptEdits" as const,
      extraArgs: { "replay-user-messages": null }
    }
  });

  let safeCheckpoint: string | undefined;

  for await (const message of response) {
    // Update checkpoint before each agent turn starts
    // This overwrites the previous checkpoint. Only keep the latest
    if (message.type === "user" && message.uuid) {
      safeCheckpoint = message.uuid;
    }

    // Decide when to revert based on your own logic
    // For example: error detection, validation failure, or user input
    if (yourRevertCondition && safeCheckpoint) {
      await response.rewindFiles(safeCheckpoint);
      // Exit the loop after rewinding, files are restored
      break;
    }
  }
}

main();

Mehrere Wiederherstellungspunkte

Wenn Claude Änderungen über mehrere Turns hinweg vornimmt, möchten Sie möglicherweise zu einem bestimmten Punkt zurückspulen, anstatt ganz nach hinten zu gehen. Wenn Claude beispielsweise eine Datei in Turn eins umgestaltet und Tests in Turn zwei hinzufügt, möchten Sie möglicherweise die Umgestaltung behalten, aber die Tests rückgängig machen.

Dieses Muster speichert alle Checkpoint-UUIDs in einem Array mit Metadaten. Nach Abschluss der Sitzung können Sie zu jedem vorherigen Checkpoint zurückspulen:

import asyncio
from dataclasses import dataclass
from datetime import datetime
from claude_agent_sdk import (
    ClaudeSDKClient,
    ClaudeAgentOptions,
    UserMessage,
    ResultMessage,
)


# Store checkpoint metadata for better tracking
@dataclass
class Checkpoint:
    id: str
    description: str
    timestamp: datetime


async def main():
    options = ClaudeAgentOptions(
        enable_file_checkpointing=True,
        permission_mode="acceptEdits",
        extra_args={"replay-user-messages": None},
    )

    checkpoints = []
    session_id = None

    async with ClaudeSDKClient(options) as client:
        await client.query("Refactor the authentication module")

        async for message in client.receive_response():
            if isinstance(message, UserMessage) and message.uuid:
                checkpoints.append(
                    Checkpoint(
                        id=message.uuid,
                        description=f"After turn {len(checkpoints) + 1}",
                        timestamp=datetime.now(),
                    )
                )
            if isinstance(message, ResultMessage) and not session_id:
                session_id = message.session_id

    # Later: rewind to any checkpoint by resuming the session
    if checkpoints and session_id:
        target = checkpoints[0]  # Pick any checkpoint
        async with ClaudeSDKClient(
            ClaudeAgentOptions(enable_file_checkpointing=True, resume=session_id)
        ) as client:
            await client.query("")  # Empty prompt to open the connection
            async for message in client.receive_response():
                await client.rewind_files(target.id)
                break
        print(f"Rewound to: {target.description}")


asyncio.run(main())

import { query } from "@anthropic-ai/claude-agent-sdk";

// Store checkpoint metadata for better tracking
interface Checkpoint {
  id: string;
  description: string;
  timestamp: Date;
}

async function main() {
  const opts = {
    enableFileCheckpointing: true,
    permissionMode: "acceptEdits" as const,
    extraArgs: { "replay-user-messages": null }
  };

  const response = query({
    prompt: "Refactor the authentication module",
    options: opts
  });

  const checkpoints: Checkpoint[] = [];
  let sessionId: string | undefined;

  try {
    for await (const message of response) {
      if (message.type === "user" && message.uuid) {
        checkpoints.push({
          id: message.uuid,
          description: `After turn ${checkpoints.length + 1}`,
          timestamp: new Date()
        });
      }
      if ("session_id" in message && !sessionId) {
        sessionId = message.session_id;
      }
    }
  } catch (error) {
    // A single-shot query() throws after yielding an error result. If the
    // failure was an error result, sessionId and the checkpoints array were
    // already populated by the loop above; connection or process failures
    // yield no result message.
    console.error(`Session ended with an error: ${error}`);
  }

  // Later: rewind to any checkpoint by resuming the session
  if (checkpoints.length > 0 && sessionId) {
    const target = checkpoints[0]; // Pick any checkpoint
    const rewindQuery = query({
      prompt: "", // Empty prompt to open the connection
      options: { ...opts, resume: sessionId }
    });

    for await (const msg of rewindQuery) {
      await rewindQuery.rewindFiles(target.id);
      break;
    }
    console.log(`Rewound to: ${target.description}`);
  }
}

main();

Ausprobieren

Dieses vollständige Beispiel erstellt eine kleine Utility-Datei, lässt den Agent Dokumentationskommentare hinzufügen, zeigt Ihnen die Änderungen und fragt dann, ob Sie zurückspulen möchten.

Bevor Sie beginnen, stellen Sie sicher, dass Sie das Claude Agent SDK installiert haben.

1. Testdatei erstellen

Erstellen Sie eine neue Datei namens utils.py (Python) oder utils.ts (TypeScript) und fügen Sie den folgenden Code ein:

def add(a, b):
    return a + b


def subtract(a, b):
    return a - b


def multiply(a, b):
    return a * b


def divide(a, b):
    if b == 0:
        raise ValueError("Cannot divide by zero")
    return a / b

export function add(a: number, b: number): number {
  return a + b;
}

export function subtract(a: number, b: number): number {
  return a - b;
}

export function multiply(a: number, b: number): number {
  return a * b;
}

export function divide(a: number, b: number): number {
  if (b === 0) {
    throw new Error("Cannot divide by zero");
  }
  return a / b;
}

2. Interaktives Beispiel ausführen

Erstellen Sie eine neue Datei namens try_checkpointing.py (Python) oder try_checkpointing.ts (TypeScript) im selben Verzeichnis wie Ihre Utility-Datei und fügen Sie den folgenden Code ein.

Dieses Skript fordert Claude auf, Dokumentationskommentare zu Ihrer Utility-Datei hinzuzufügen, und gibt Ihnen dann die Möglichkeit, zurückzuspulen und das Original wiederherzustellen.

import asyncio
from claude_agent_sdk import (
    ClaudeSDKClient,
    ClaudeAgentOptions,
    UserMessage,
    ResultMessage,
)


async def main():
    # Configure the SDK with checkpointing enabled
    # - enable_file_checkpointing: Track file changes for rewinding
    # - permission_mode: Auto-accept file edits without prompting
    # - extra_args: Required to receive user message UUIDs in the stream
    options = ClaudeAgentOptions(
        enable_file_checkpointing=True,
        permission_mode="acceptEdits",
        extra_args={"replay-user-messages": None},
    )

    checkpoint_id = None  # Store the user message UUID for rewinding
    session_id = None  # Store the session ID for resuming

    print("Running agent to add doc comments to utils.py...\n")

    # Run the agent and capture checkpoint data from the response stream
    async with ClaudeSDKClient(options) as client:
        await client.query("Add doc comments to utils.py")

        async for message in client.receive_response():
            # Capture the first user message UUID - this is our restore point
            if isinstance(message, UserMessage) and message.uuid and not checkpoint_id:
                checkpoint_id = message.uuid
            # Capture the session ID so we can resume later
            if isinstance(message, ResultMessage):
                session_id = message.session_id

    print("Done! Open utils.py to see the added doc comments.\n")

    # Ask the user if they want to rewind the changes
    if checkpoint_id and session_id:
        response = input("Rewind to remove the doc comments? (y/n): ")

        if response.lower() == "y":
            # Resume the session with an empty prompt, then rewind
            async with ClaudeSDKClient(
                ClaudeAgentOptions(enable_file_checkpointing=True, resume=session_id)
            ) as client:
                await client.query("")  # Empty prompt opens the connection
                async for message in client.receive_response():
                    await client.rewind_files(checkpoint_id)  # Restore files
                    break

            print(
                "\n✓ File restored! Open utils.py to verify the doc comments are gone."
            )
        else:
            print("\nKept the modified file.")


asyncio.run(main())

import { query } from "@anthropic-ai/claude-agent-sdk";
import * as readline from "readline";

async function main() {
  // Configure the SDK with checkpointing enabled
  // - enableFileCheckpointing: Track file changes for rewinding
  // - permissionMode: Auto-accept file edits without prompting
  // - extraArgs: Required to receive user message UUIDs in the stream
  const opts = {
    enableFileCheckpointing: true,
    permissionMode: "acceptEdits" as const,
    extraArgs: { "replay-user-messages": null }
  };

  let sessionId: string | undefined; // Store the session ID for resuming
  let checkpointId: string | undefined; // Store the user message UUID for rewinding

  console.log("Running agent to add doc comments to utils.ts...\n");

  // Run the agent and capture checkpoint data from the response stream
  const response = query({
    prompt: "Add doc comments to utils.ts",
    options: opts
  });

  try {
    for await (const message of response) {
      // Capture the first user message UUID - this is our restore point
      if (message.type === "user" && message.uuid && !checkpointId) {
        checkpointId = message.uuid;
      }
      // Capture the session ID so we can resume later
      if ("session_id" in message) {
        sessionId = message.session_id;
      }
    }
  } catch (error) {
    // A single-shot query() throws after yielding an error result. If the
    // failure was an error result, checkpointId and sessionId were already
    // captured by the loop above; connection or process failures yield no
    // result message.
    console.error(`Session ended with an error: ${error}`);
  }

  console.log("Done! Open utils.ts to see the added doc comments.\n");

  // Ask the user if they want to rewind the changes
  if (checkpointId && sessionId) {
    const rl = readline.createInterface({
      input: process.stdin,
      output: process.stdout
    });

    const answer = await new Promise<string>((resolve) => {
      rl.question("Rewind to remove the doc comments? (y/n): ", resolve);
    });
    rl.close();

    if (answer.toLowerCase() === "y") {
      // Resume the session with an empty prompt, then rewind
      const rewindQuery = query({
        prompt: "", // Empty prompt opens the connection
        options: { ...opts, resume: sessionId }
      });

      for await (const msg of rewindQuery) {
        await rewindQuery.rewindFiles(checkpointId); // Restore files
        break;
      }

      console.log("\n✓ File restored! Open utils.ts to verify the doc comments are gone.");
    } else {
      console.log("\nKept the modified file.");
    }
  }
}

main();

3. Beispiel ausführen

Führen Sie das Skript aus dem selben Verzeichnis wie Ihre Utility-Datei aus.

[!TIP]

Öffnen Sie Ihre Utility-Datei (utils.py oder utils.ts) in Ihrer IDE oder Ihrem Editor, bevor Sie das Skript ausführen. Sie sehen, wie die Datei in Echtzeit aktualisiert wird, während der Agent Dokumentationskommentare hinzufügt, und dann zum Original zurückkehrt, wenn Sie sich zum Zurückspulen entscheiden.

[tab] Python

python try_checkpointing.py

[tab] TypeScript

npx tsx try_checkpointing.ts

Sie sehen, dass der Agent Dokumentationskommentare hinzufügt, dann eine Eingabeaufforderung, die fragt, ob Sie zurückspulen möchten. Wenn Sie ja wählen, wird die Datei in ihren ursprünglichen Zustand zurückgesetzt.

Einschränkungen

File Checkpointing hat die folgenden Einschränkungen:

Troubleshooting

Checkpointing-Optionen nicht erkannt

Wenn enableFileCheckpointing oder rewindFiles() nicht verfügbar ist, verwenden Sie möglicherweise eine ältere SDK-Version.

Lösung: Aktualisieren Sie auf die neueste SDK-Version:

• Python: pip install --upgrade claude-agent-sdk
• TypeScript: npm install @anthropic-ai/claude-agent-sdk@latest

Benutzermeldungen haben keine UUIDs

Wenn message.uuid undefined oder fehlend ist, erhalten Sie keine Checkpoint-UUIDs.

Ursache: Die Option replay-user-messages ist nicht gesetzt.

Lösung: Fügen Sie extra_args={"replay-user-messages": None} (Python) oder extraArgs: { 'replay-user-messages': null } (TypeScript) zu Ihren Optionen hinzu.

Fehler „No file checkpoint found for this message“

Dieser Fehler tritt auf, wenn die Checkpoint-Daten für die angegebene Benutzermeldungs-UUID nicht vorhanden sind.

Häufige Ursachen:

• File Checkpointing war in der ursprünglichen Sitzung nicht aktiviert (enable_file_checkpointing oder enableFileCheckpointing war nicht auf true gesetzt)
• Die Sitzung wurde nicht vollständig abgeschlossen, bevor versucht wurde, sie fortzusetzen und zurückzuspulen

Lösung: Stellen Sie sicher, dass enable_file_checkpointing=True (Python) oder enableFileCheckpointing: true (TypeScript) in der ursprünglichen Sitzung gesetzt war, verwenden Sie dann das in den Beispielen gezeigte Muster: Erfassen Sie die UUID der ersten Benutzermeldung, schließen Sie die Sitzung vollständig ab, setzen Sie sie dann mit einer leeren Eingabeaufforderung fort und rufen Sie rewindFiles() einmal auf.

Fehler „File rewinding is not enabled“

Dieser Fehler tritt auf, wenn Sie versuchen, ein nicht-interaktives Zurückspulen ohne aktiviertes Checkpointing durchzuführen: Ausführung von bare claude -p mit --rewind-files, oder Ausführung einer SDK-Sitzung, einschließlich einer fortgesetzten, deren Optionen Checkpointing nicht aktivieren. Das SDK setzt die Umgebungsvariable CLAUDE_CODE_ENABLE_SDK_FILE_CHECKPOINTING intern nur dann, wenn enable_file_checkpointing (Python) oder enableFileCheckpointing (TypeScript) in der Sitzung aktiviert ist, die das Zurückspulen durchführt; die bare CLI setzt sie nie.

Lösung: Für die bare CLI setzen Sie die Umgebungsvariable beim Ausführen des Befehls:

CLAUDE_CODE_ENABLE_SDK_FILE_CHECKPOINTING=true claude -p --resume <session-id> --rewind-files <checkpoint-uuid>

Für das SDK setzen Sie enable_file_checkpointing=True (Python) oder enableFileCheckpointing: true (TypeScript) in der fortgesetzten Sitzung, wie die Beispiele auf dieser Seite zeigen.

Fehler „ProcessTransport is not ready for writing“

Dieser Fehler tritt auf, wenn Sie rewindFiles() oder rewind_files() aufrufen, nachdem Sie die Iteration durch die Antwort abgeschlossen haben. Die Verbindung zum CLI-Prozess wird geschlossen, wenn die Schleife abgeschlossen ist.

Lösung: Setzen Sie die Sitzung mit einer leeren Eingabeaufforderung fort und rufen Sie dann rewind auf der neuen Abfrage auf. Das führende Beispiel unter Implement checkpointing zeigt den Resume-and-Rewind-Aufruf in beiden Sprachen, bei dem Kommentar mit der Bezeichnung Step 3.

Nächste Schritte

• Sessions: Erfahren Sie, wie Sie Sitzungen fortsetzen, was zum Zurückspulen nach Abschluss des Streams erforderlich ist. Behandelt Session-IDs, Fortsetzen von Gesprächen und Session-Forking.
• Berechtigungen: Konfigurieren Sie, welche Tools Claude verwenden kann und wie Dateiänderungen genehmigt werden. Nützlich, wenn Sie mehr Kontrolle darüber haben möchten, wann Änderungen vorgenommen werden.
• TypeScript SDK-Referenz: Vollständige API-Referenz einschließlich aller Optionen für query() und die Methode rewindFiles().
• Python SDK-Referenz: Vollständige API-Referenz einschließlich aller Optionen für ClaudeAgentOptions und die Methode rewind_files().