Code-Execution-Tool

Claude kann Daten analysieren, Visualisierungen erstellen, komplexe Berechnungen durchführen, Systembefehle ausführen, Dateien erstellen und bearbeiten sowie hochgeladene Dateien direkt innerhalb der API-Konversation verarbeiten. Das Code-Execution-Tool (Werkzeug zur Codeausführung) ermöglicht es Claude, Bash-Befehle auszuführen und Dateien zu manipulieren, einschließlich des Schreibens von Code, in einer sicheren, sandboxed Umgebung.

Code Execution ist kostenlos, wenn sie mit Web Search oder Web Fetch verwendet wird (web_search_20260209, web_fetch_20260209 oder neuer). Wenn eines dieser Tools in deiner Anfrage enthalten ist, fallen für Code Execution in dieser Anfrage keine zusätzlichen Kosten über die Standard-Token-Kosten hinaus an. Dies umfasst sowohl die Code Execution hinter dem dynamischen Filtern als auch jeglichen Code, den Claude direkt ausführt. Die Standard-Preise für Code Execution gelten, wenn diese nicht enthalten sind.

Code Execution treibt auch das dynamische Filtern in den Tools Web Search und Web Fetch an: Claude filtert Ergebnisse innerhalb der Code-Execution-Umgebung, bevor sie das Kontextfenster erreichen. Wenn dynamisches Filtern läuft, stellt die API die dafür benötigte Code Execution für die Anfrage automatisch bereit, sodass du das Code-Execution-Tool dafür nicht zu deiner Anfrage hinzufügen musst.



Modellkompatibilität

Das Code-Execution-Tool ist für die folgenden Modelle verfügbar:

Jede Tool-Version baut auf der vorherigen auf:

• code_execution_20250825 unterstützt Bash-Befehle und Dateioperationen und ist für jedes Modell in der Tabelle verfügbar.
• code_execution_20260120 fügt REPL-Zustandspersistenz und Programmatic Tool Calling aus der Sandbox heraus hinzu. Claude Haiku 4.5 akzeptiert die Tool-Typen code_execution_20260120 und code_execution_20260521, aber Programmatic Tool Calling und die davon abhängige REPL-Zustandspersistenz sind dort nicht verfügbar, sodass sich die neueren Versionen dort wie code_execution_20250825 verhalten.
• code_execution_20260521 ist dieselbe Laufzeitumgebung wie code_execution_20260120. Der Unterschied besteht darin, dass die Tool-Beschreibung Claude über das 90-Sekunden-Echtzeitlimit für jede Python-Zelle beim Programmatic Tool Calling informiert, sodass Claude lang laufende Zellen einplanen kann. Eine Zelle, die das Limit überschreitet, gibt ein normales Code-Execution-Ergebnis mit einem return_code ungleich null und einer detection_timeout-Statusmeldung in ihrer Ausgabe zurück. Dies ist getrennt vom Fehlercode execution_time_exceeded, den die API zurückgibt, wenn ein gesamter Tool-Aufruf die maximale Ausführungszeit überschreitet.

Alle drei Tool-Versionen sind allgemein verfügbar und erfordern keinen anthropic-beta-Header. Die Legacy-Beta-Header für Code Execution bleiben gültige Opt-ins.

Die Beispiele auf dieser Seite verwenden code_execution_20250825, weil jedes Modell in der Tabelle es unterstützt. Die aktuellen Tools für Web Search und Web Fetch (web_search_20260209, web_fetch_20260209 und neuer) erfordern code_execution_20260120 oder neuer als ihre Code-Execution-Version.



Plattformverfügbarkeit

Code Execution ist verfügbar auf:

• Claude API (Anthropic)
• Claude Platform on AWS
• Microsoft Foundry (erfordert ein Hosted on Anthropic Deployment)

Code Execution ist derzeit nicht auf Amazon Bedrock oder Google Cloud verfügbar.



Schnellstart

Hier ist ein einfaches Beispiel, das Claude bittet, eine Berechnung durchzuführen:

client = anthropic.Anthropic()

response = client.messages.create(
    model="claude-opus-4-8",
    max_tokens=4096,
    messages=[
        {
            "role": "user",
            "content": "Use the code execution tool to calculate the mean and standard deviation of [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]",
        }
    ],
    tools=[{"type": "code_execution_20250825", "name": "code_execution"}],
)

print(response.to_json())

Die Antwort verschachtelt server_tool_use-Blöcke (die Befehle, die Claude ausgeführt hat) mit ihren Tool-Result-Blöcken, gefolgt von Claudes Text. Die oberste Ebene enthält außerdem ein container-Objekt, dessen id du über Anfragen hinweg wiederverwenden kannst. Siehe Antwortformat für die Block-Strukturen.



Wie Code Execution funktioniert

Wenn du das Code-Execution-Tool zu deiner API-Anfrage hinzufügst:

1. Claude bewertet, ob Code Execution helfen würde, deine Frage zu beantworten
2. Das Tool stellt Claude automatisch die folgenden Fähigkeiten zur Verfügung:
   • Bash-Befehle: Shell-Befehle für Systemoperationen ausführen
   • Dateioperationen: Dateien direkt erstellen, anzeigen und bearbeiten, einschließlich des Schreibens von Code
3. Claude kann jede Kombination dieser Fähigkeiten in einer einzigen Anfrage verwenden
4. Alle Operationen laufen in einem sicheren, sandboxed Container. Der Container hat keinen Internetzugang, daher kann Claude zur Laufzeit keine Pakete herunterladen: Nur die vorinstallierten Bibliotheken sind verfügbar
5. Die API führt jeden Befehl serverseitig aus und gibt die Ergebnisse innerhalb derselben Anfrage an Claude zurück, sodass du niemals selbst Code ausführst oder tool_result-Blöcke zurücksendest. Eine Ausnahme besteht, wenn Claude eines deiner Client-Tools zusammen mit Code Execution aufruft: Die API gibt den Code-Execution-Aufruf ohne sein Ergebnis zurück. Das Ergebnis kommt in einer späteren Antwort an, nachdem du die tool_result-Blöcke für deine Client-Tools zurückgesendet hast
6. Jede Anfrage läuft in einem neuen Container, es sei denn, du übergibst die Container-ID einer früheren Antwort zurück (siehe Container-Wiederverwendung)
7. Claude liefert Ergebnisse mit allen generierten Diagrammen, Berechnungen oder Analysen

Der Container hat Python vorinstalliert. Claude schreibt Python mit dem Dateioperationen-Sub-Tool und führt es mit einem Bash-Befehl aus. Mit code_execution_20260120 oder neuer und Programmatic Tool Calling bleibt auch der Zustand des Python-Interpreters (wie Variablenbindungen) über Anfragen hinweg erhalten, die den Container wiederverwenden.



Wann Claude Code ausführt

Claude führt Code aus, wenn die Anfrage von Berechnungen oder Dateiverarbeitung profitiert:

• Nicht-triviale Mathematik (große Zahlen, viele Schritte, präzisionsempfindliche Ergebnisse)
• Datenanalyse, Datei-Parsing oder Visualisierung
• Algorithmus-Ausführung oder Simulation
• Explizite Aufforderungen zum „Ausführen", „Berechnen" oder „Ausführen lassen"

Claude antwortet direkt, ohne Code auszuführen, bei:

• Einfacher Arithmetik und bekannten mathematischen Fakten
• Faktischen, konversationellen oder kreativen Anfragen
• Einfachen Einheitenumrechnungen oder Übersetzungen

Wenn du möchtest, dass Claude bei einer Grenzfall-Anfrage Code ausführt, frage explizit danach (zum Beispiel: „führe Code aus, um das zu verifizieren").



Mit Dateien arbeiten



Eigene Dateien hochladen und analysieren

Um deine eigenen Datendateien (wie CSV, Excel oder Bilder) zu analysieren, lade sie über die Files API hoch und referenziere sie in deiner Anfrage:

Die Python-Umgebung kann verschiedene Dateitypen verarbeiten, die über die Files API hochgeladen wurden, darunter:

• CSV
• Excel (.xlsx, .xls)
• JSON
• XML
• Bilder (JPEG, PNG, GIF, WebP)
• Textdateien (.txt, .md, .py und andere)



Dateien hochladen und analysieren

1. Lade deine Datei hoch mit der Files API
2. Referenziere die Datei in deiner Nachricht mit einem container_upload-Content-Block
3. Füge das Code-Execution-Tool in deine API-Anfrage ein

client = anthropic.Anthropic()

# Lade eine Datei hoch
file_object = client.beta.files.upload(file=Path("data.csv"))

# Verwende die file_id mit Code-Ausführung
response = client.beta.messages.create(
    model="claude-opus-4-8",
    betas=["files-api-2025-04-14"],
    max_tokens=4096,
    messages=[
        {
            "role": "user",
            "content": [
                {"type": "text", "text": "Analyze this CSV data"},
                {"type": "container_upload", "file_id": file_object.id},
            ],
        }
    ],
    tools=[{"type": "code_execution_20250825", "name": "code_execution"}],
)

print(response.to_json())



Generierte Dateien abrufen

Wenn Claude während der Code Execution Dateien erstellt, erscheint die ID jeder erstellten Datei im Code-Execution-Tool-Ergebnis, und du kannst sie mit der Files API herunterladen:

client = Anthropic()

# Fordere Code-Ausführung an, die Dateien erstellt
response = client.beta.messages.create(
    model="claude-opus-4-8",
    betas=["files-api-2025-04-14"],
    max_tokens=4096,
    messages=[
        {
            "role": "user",
            "content": "Create a matplotlib visualization and save it as output.png",
        }
    ],
    tools=[{"type": "code_execution_20250825", "name": "code_execution"}],
)


# Extrahiere Datei-IDs aus der Antwort
def extract_file_ids(response: BetaMessage) -> list[str]:
    file_ids: list[str] = []
    for item in response.content:
        if item.type == "bash_code_execution_tool_result":
            content_item = item.content
            if content_item.type == "bash_code_execution_result":
                for output_block in content_item.content:
                    file_ids.append(output_block.file_id)
    return file_ids


# Lade die erstellten Dateien herunter
for file_id in extract_file_ids(response):
    file_metadata = client.beta.files.retrieve_metadata(file_id)
    file_content = client.beta.files.download(file_id)
    file_content.write_to_file(file_metadata.filename)
    print(f"Downloaded: {file_metadata.filename}")



Tool-Definition

Das Code-Execution-Tool erfordert keine zusätzlichen Parameter:

{
  "type": "code_execution_20250825",
  "name": "code_execution"
}

Beide Felder sind fest: type wählt die Tool-Version aus, und name muss code_execution sein.

Wenn dieses Tool bereitgestellt wird, erhält Claude automatisch Zugriff auf zwei Sub-Tools:

• bash_code_execution: Shell-Befehle ausführen
• text_editor_code_execution: Dateien anzeigen, erstellen und bearbeiten, einschließlich des Schreibens von Code

Wenn Claude Code ausführt, enthält die Antwort auch ein container-Objekt auf oberster Ebene mit der id des Containers und dem expires_at-Zeitstempel. Übergib diese ID im container-Anfrageparameter auf oberster Ebene zurück, um denselben Container weiter zu verwenden. Siehe Container-Wiederverwendung.



Antwortformat

Das Code-Execution-Tool kann je nach Operation zwei Arten von Ergebnissen zurückgeben:



Bash-Befehl-Antwort

{
  "type": "server_tool_use",
  "id": "srvtoolu_01B3C4D5E6F7G8H9I0J1K2L3",
  "name": "bash_code_execution",
  "input": {
    "command": "ls -la | head -5"
  }
},
{
  "type": "bash_code_execution_tool_result",
  "tool_use_id": "srvtoolu_01B3C4D5E6F7G8H9I0J1K2L3",
  "content": {
    "type": "bash_code_execution_result",
    "stdout": "total 24\ndrwxr-xr-x 2 user user 4096 Jan 1 12:00 .\ndrwxr-xr-x 3 user user 4096 Jan 1 11:00 ..\n-rw-r--r-- 1 user user  220 Jan 1 12:00 data.csv\n-rw-r--r-- 1 user user  180 Jan 1 12:00 config.json",
    "stderr": "",
    "return_code": 0,
    "content": []
  }
}



Dateioperation-Antworten

Datei anzeigen:

{
  "type": "server_tool_use",
  "id": "srvtoolu_01C4D5E6F7G8H9I0J1K2L3M4",
  "name": "text_editor_code_execution",
  "input": {
    "command": "view",
    "path": "config.json"
  }
},
{
  "type": "text_editor_code_execution_tool_result",
  "tool_use_id": "srvtoolu_01C4D5E6F7G8H9I0J1K2L3M4",
  "content": {
    "type": "text_editor_code_execution_view_result",
    "file_type": "text",
    "content": "{\n  \"setting\": \"value\",\n  \"debug\": true\n}",
    "num_lines": 4,
    "start_line": 1,
    "total_lines": 4
  }
}

Datei erstellen:

{
  "type": "server_tool_use",
  "id": "srvtoolu_01D5E6F7G8H9I0J1K2L3M4N5",
  "name": "text_editor_code_execution",
  "input": {
    "command": "create",
    "path": "new_file.txt",
    "file_text": "Hello, World!"
  }
},
{
  "type": "text_editor_code_execution_tool_result",
  "tool_use_id": "srvtoolu_01D5E6F7G8H9I0J1K2L3M4N5",
  "content": {
    "type": "text_editor_code_execution_create_result",
    "is_file_update": false
  }
}

Datei bearbeiten (str_replace):

{
  "type": "server_tool_use",
  "id": "srvtoolu_01E6F7G8H9I0J1K2L3M4N5O6",
  "name": "text_editor_code_execution",
  "input": {
    "command": "str_replace",
    "path": "config.json",
    "old_str": "\"debug\": true",
    "new_str": "\"debug\": false"
  }
},
{
  "type": "text_editor_code_execution_tool_result",
  "tool_use_id": "srvtoolu_01E6F7G8H9I0J1K2L3M4N5O6",
  "content": {
    "type": "text_editor_code_execution_str_replace_result",
    "old_start": 3,
    "old_lines": 1,
    "new_start": 3,
    "new_lines": 1,
    "lines": ["-  \"debug\": true", "+  \"debug\": false"]
  }
}



Ergebnisse

Bash-Befehl-Ergebnisse (bash_code_execution_result) enthalten:

• stdout: Ausgabe bei erfolgreicher Ausführung
• stderr: Fehlermeldungen, wenn die Ausführung fehlschlägt
• return_code: 0 für Erfolg, ungleich null für Fehler
• content: Eine Liste mit einem Eintrag für jede Datei, die der Befehl erstellt hat. Jeder Eintrag enthält die file_id, um die Datei abzurufen mit der Files API

Dateioperation-Ergebnisse haben ihre eigenen Felder:

• View (text_editor_code_execution_view_result): file_type, content, num_lines, start_line, total_lines
• Create (text_editor_code_execution_create_result): is_file_update (ob die Datei bereits existierte)
• Edit (text_editor_code_execution_str_replace_result): old_start, old_lines, new_start, new_lines, lines (Diff-Format)



Fehler

Jeder Tool-Typ kann spezifische Fehler zurückgeben:

Häufige Fehler (alle Tools):

{
  "type": "bash_code_execution_tool_result",
  "tool_use_id": "srvtoolu_01VfmxgZ46TiHbmXgy928hQR",
  "content": {
    "type": "bash_code_execution_tool_result_error",
    "error_code": "unavailable"
  }
}

Fehlercodes nach Tool-Typ:

Ein abgelaufener Container kann nicht wiederverwendet werden: Anfragen, die ihn referenzieren, geben einen Fehler zurück, anstatt ihn wiederherzustellen. Sende die Anfrage erneut ohne den container-Parameter, um einen neuen Container zu erhalten.



pause_turn Stop-Reason

Die Antwort kann einen pause_turn Stop-Reason enthalten, der anzeigt, dass die API einen lang laufenden Turn pausiert hat. Du kannst die Antwort unverändert in einer nachfolgenden Anfrage zurückgeben, damit Claude seinen Turn fortsetzen kann, oder den Inhalt ändern, wenn du die Konversation unterbrechen möchtest.



Container

Das Code-Execution-Tool läuft in einer sicheren, containerisierten Umgebung, die speziell für Code Execution entwickelt wurde, mit einem stärkeren Fokus auf Python.



Laufzeitumgebung

• Python-Version: 3.11
• Betriebssystem: Linux-basierter Container
• Architektur: x86_64 (AMD64)



Ressourcenlimits

• Arbeitsspeicher: 5 GiB RAM
• Speicherplatz: 5 GiB Workspace-Speicher
• CPU: 1 CPU
• Ausführungszeit: Ein Tool-Aufruf, der die maximale Ausführungszeit überschreitet, gibt einen execution_time_exceeded-Fehler zurück. Mit Programmatic Tool Calling hat jede REPL-Zelle zusätzlich ein 90-Sekunden-Echtzeitlimit



Netzwerk und Sicherheit

• Internetzugang: Aus Sicherheitsgründen vollständig deaktiviert
• Externe Verbindungen: Keine ausgehenden Netzwerkanfragen erlaubt
• Sandbox-Isolation: Vollständige Isolation vom Host-System und anderen Containern
• Dateizugriff: Nur auf das Workspace-Verzeichnis beschränkt
• Workspace-Scoping: Wie bei Files sind Container auf den Workspace des API-Keys beschränkt
• Ablauf: Container laufen 30 Tage nach der Erstellung ab



Vorinstallierte Bibliotheken

Die sandboxed Python-Umgebung enthält diese häufig verwendeten Bibliotheken:

• Data Science: pandas, numpy, scipy, scikit-learn, statsmodels
• Visualisierung: matplotlib, seaborn
• Dateiverarbeitung: pyarrow, openpyxl, xlsxwriter, xlrd, pillow, python-pptx, python-docx, pypdf, pdfplumber, pypdfium2, pdf2image, pdfkit, tabula-py, reportlab[pycairo], Img2pdf
• Mathematik und Berechnung: sympy, mpmath
• Hilfsprogramme: tqdm, python-dateutil, pytz, joblib

Der Container enthält auch Kommandozeilen-Tools wie unzip, unrar, 7zip, bc, rg (ripgrep), fd und sqlite.

Der Container hat keinen Internetzugang, daher kann Claude zur Laufzeit keine zusätzlichen Pakete herunterladen oder installieren: Nur die vorinstallierten Bibliotheken sind verfügbar.



Container-Wiederverwendung

Du kannst einen bestehenden Container über mehrere API-Anfragen hinweg wiederverwenden, indem du die Container-ID aus einer vorherigen Antwort angibst. Dies ermöglicht es dir, erstellte Dateien zwischen Anfragen beizubehalten. Mit code_execution_20260120 oder neuer und Programmatic Tool Calling bleibt auch der Zustand des Python-Interpreters erhalten.

Container laufen 30 Tage nach der Erstellung ab. Nach etwa fünf Minuten Inaktivität wird ein Container per Checkpoint gesichert, und das Senden einer Anfrage mit seiner ID innerhalb des 30-Tage-Fensters stellt ihn wieder her. Der expires_at-Zeitstempel im container-Objekt der Antwort ist ein kürzerer, rollierender Wert und gibt nicht das 30-Tage-Limit an. Ein abgelaufener Container kann nicht wiederverwendet werden. Sende die Anfrage erneut ohne den container-Parameter, um einen neuen Container zu erhalten.



Beispiel

client = anthropic.Anthropic()

# Erste Anfrage: Erstelle eine Datei mit einer Zufallszahl in einem neuen Container
response1 = client.messages.create(
    model="claude-opus-4-8",
    max_tokens=4096,
    messages=[
        {
            "role": "user",
            "content": "Write a file with a random number and save it to '/tmp/number.txt'",
        }
    ],
    tools=[{"type": "code_execution_20250825", "name": "code_execution"}],
)

# Zweite Anfrage: Übergib die Container-ID zurück, damit Claude denselben Container wiederverwendet
response2 = client.messages.create(
    container=response1.container.id,
    model="claude-opus-4-8",
    max_tokens=4096,
    messages=[
        {
            "role": "user",
            "content": "Read the number from '/tmp/number.txt' and calculate its square",
        }
    ],
    tools=[{"type": "code_execution_20250825", "name": "code_execution"}],
)

print(response2.to_json())



Code Execution mit anderen Ausführungs-Tools verwenden

Wenn du Code Execution zusammen mit clientseitig bereitgestellten Tools anbietest, die ebenfalls Code ausführen (wie ein Bash-Tool oder eine benutzerdefinierte REPL), arbeitet Claude in einer Multi-Computer-Umgebung. Das Code-Execution-Tool läuft in Anthropics sandboxed Container, während deine clientseitig bereitgestellten Tools in einer separaten Umgebung laufen, die du kontrollierst. Claude kann diese Umgebungen manchmal verwechseln und versuchen, das falsche Tool zu verwenden oder anzunehmen, dass der Zustand zwischen ihnen geteilt wird.

Um dies zu vermeiden, füge deinem System-Prompt Anweisungen hinzu, die den Unterschied verdeutlichen:

When multiple code execution environments are available, be aware that:
- Variables, files, and state do NOT persist between different execution environments
- Use the code_execution tool for general-purpose computation in Anthropic's sandboxed environment
- Use client-provided execution tools (e.g., bash) when you need access to the user's local system, files, or data
- If you need to pass results between environments, explicitly include outputs in subsequent tool calls rather than assuming shared state

Dies ist besonders wichtig, wenn Code Execution mit Web Search oder Web Fetch kombiniert wird, die Code Execution automatisch aktivieren. Wenn deine Anwendung bereits ein clientseitiges Shell-Tool bereitstellt, erzeugt die automatische Code Execution eine zweite Ausführungsumgebung, zwischen denen Claude unterscheiden muss.

Wenn Claude eines deiner Client-Tools zusammen mit Code Execution aufruft, gibt die API den Code-Execution-Aufruf ohne sein Ergebnis zurück. Das Ergebnis kommt in einer späteren Antwort an, nachdem du die tool_result-Blöcke für deine Client-Tools zurückgesendet hast.



Streaming

Mit aktiviertem Streaming ("stream": true) erhältst du Code-Execution-Events, sobald sie auftreten. Die Sub-Tool-Eingabe wird als input_json_delta-Events gestreamt, und jeder Result-Block kommt vollständig in einem einzelnen content_block_start-Event an:

event: content_block_start
data: {"type": "content_block_start", "index": 1, "content_block": {"type": "server_tool_use", "id": "srvtoolu_xyz789", "name": "bash_code_execution"}}

// Tool input streamed as partial JSON
event: content_block_delta
data: {"type": "content_block_delta", "index": 1, "delta": {"type": "input_json_delta", "partial_json": "{\"command\": \"python analyze.py\"}"}}

// Pause while the command runs

// Execution result delivered as a complete block
event: content_block_start
data: {"type": "content_block_start", "index": 2, "content_block": {"type": "bash_code_execution_tool_result", "tool_use_id": "srvtoolu_xyz789", "content": {"type": "bash_code_execution_result", "stdout": "   A  B  C\n0  1  2  3\n1  4  5  6", "stderr": "", "return_code": 0, "content": []}}}



Batch-Anfragen

Du kannst das Code-Execution-Tool in die Messages Batches API einbinden. Code-Execution-Tool-Aufrufe über die Messages Batches API werden genauso berechnet wie die in regulären Messages-API-Anfragen.



Nutzung und Preise

Code-Ausführung ist kostenlos, wenn sie mit Websuche oder Web-Fetch verwendet wird. Wenn web_search_20260209 (oder neuer) oder web_fetch_20260209 (oder neuer) in deiner API-Anfrage enthalten ist, fallen für Aufrufe des Code-Ausführungs-Tools keine zusätzlichen Kosten an, abgesehen von den standardmäßigen Kosten für Input- und Output-Token.

Bei Verwendung ohne diese Tools wird die Code-Ausführung nach Ausführungszeit abgerechnet, die getrennt von der Token-Nutzung erfasst wird:

• Die Ausführungszeit hat ein Minimum von 5 Minuten
• Jede Organisation erhält 1.550 kostenlose Stunden Nutzung pro Monat
• Zusätzliche Nutzung über 1.550 Stunden hinaus wird mit 0,05 $ pro Stunde, pro Container abgerechnet
• Wenn Dateien in der Anfrage enthalten sind, wird die Ausführungszeit auch dann berechnet, wenn das Tool nicht aufgerufen wird, da die Dateien vorab in den Container geladen werden

Die Nutzung der Code-Ausführung wird in der Antwort erfasst:

{
  "usage": {
    "input_tokens": 105,
    "output_tokens": 239,
    "server_tool_use": {
      "code_execution_requests": 1
    }
  }
}



Upgrade auf die neueste Tool-Version

Die neueste Tool-Version ist code_execution_20260521. Um zwischen den drei aktuellen Versionen zu wechseln, aktualisiere den type-String in deiner Anfrage: Alle drei geben die in Antwortformat dokumentierten Antwortblöcke zurück. Siehe Modellkompatibilität dafür, was jede Version hinzufügt und welche Modelle sie unterstützen.

Der Rest dieses Abschnitts behandelt die Migration vom Legacy-Tool code_execution_20250522 (nur Python) zu den aktuellen Tool-Versionen.



Was sich geändert hat



Abwärtskompatibilität

• Alle bestehenden Python-Code-Executions funktionieren weiterhin genau wie zuvor
• Keine Änderungen an bestehenden Nur-Python-Workflows erforderlich



Upgrade-Schritte

Um zu upgraden, aktualisiere den Tool-Typ in deinen API-Anfragen:

- "type": "code_execution_20250522"
+ "type": "code_execution_20250825"

Überprüfe die Antwortverarbeitung (wenn Antworten programmatisch geparst werden):

• Die bisherigen Blöcke für Python-Ausführungsantworten werden nicht mehr gesendet
• Stattdessen werden neue Antworttypen für Bash- und Dateioperationen gesendet (siehe Antwortformat)



Datenspeicherung

Code Execution läuft in serverseitigen Sandbox-Containern. Container-Daten, einschließlich Ausführungsartefakten, hochgeladenen Dateien und Ausgaben, werden bis zu 30 Tage aufbewahrt. Diese Aufbewahrung gilt für alle Daten, die innerhalb der Container-Umgebung verarbeitet werden. Dateien, die Code Execution in der Files API erstellt (abrufbar mit client.beta.files.download()), bleiben bestehen, bis sie explizit gelöscht werden.

Für die ZDR-Berechtigung über alle Features hinweg siehe API und Datenspeicherung.



Nächste Schritte