TypeScript SDK Referenz

Funktionen

`query()`

Die primäre Funktion für die Interaktion mit Claude Code. Erstellt einen asynchronen Generator, der Nachrichten streamt, während sie ankommen.

function query({
  prompt,
  options
}: {
  prompt: string | AsyncIterable<SDKUserMessage>;
  options?: Options;
}): Query

Parameter

Parameter	Typ	Beschreibung
`prompt`	`string \| AsyncIterable<SDKUserMessage>`	Die Eingabeaufforderung als String oder asynchrones Iterable für Streaming-Modus
`options`	`Options`	Optionales Konfigurationsobjekt (siehe Options-Typ unten)

Rückgabe

Gibt ein Query Objekt zurück, das AsyncGenerator<SDKMessage, void> mit zusätzlichen Methoden erweitert.

`tool()`

Erstellt eine typsichere MCP-Tool-Definition für die Verwendung mit SDK MCP-Servern.

function tool<Schema extends ZodRawShape>(
  name: string,
  description: string,
  inputSchema: Schema,
  handler: (args: z.infer<ZodObject<Schema>>, extra: unknown) => Promise<CallToolResult>
): SdkMcpToolDefinition<Schema>

Parameter

Parameter	Typ	Beschreibung
`name`	`string`	Der Name des Tools
`description`	`string`	Eine Beschreibung dessen, was das Tool tut
`inputSchema`	`Schema extends ZodRawShape`	Zod-Schema, das die Eingabeparameter des Tools definiert
`handler`	`(args, extra) => Promise<CallToolResult>`	Asynchrone Funktion, die die Tool-Logik ausführt

`createSdkMcpServer()`

Erstellt eine MCP-Server-Instanz, die im selben Prozess wie Ihre Anwendung läuft.

function createSdkMcpServer(options: {
  name: string;
  version?: string;
  tools?: Array<SdkMcpToolDefinition<any>>;
}): McpSdkServerConfigWithInstance

Parameter

Parameter	Typ	Beschreibung
`options.name`	`string`	Der Name des MCP-Servers
`options.version`	`string`	Optionaler Versionsstring
`options.tools`	`Array<SdkMcpToolDefinition>`	Array von Tool-Definitionen, erstellt mit `tool()`

Typen

`Options`

Konfigurationsobjekt für die query()-Funktion.

Eigenschaft	Typ	Standard	Beschreibung
`abortController`	`AbortController`	`new AbortController()`	Controller zum Abbrechen von Operationen
`additionalDirectories`	`string[]`	`[]`	Zusätzliche Verzeichnisse, auf die Claude zugreifen kann
`allowedTools`	`string[]`	Alle Tools	Liste der erlaubten Tool-Namen
`appendSystemPrompt`	`string`	`undefined`	Text, der an die Standard-Systemaufforderung angehängt wird
`canUseTool`	`CanUseTool`	`undefined`	Benutzerdefinierte Berechtigungsfunktion für Tool-Verwendung
`continue`	`boolean`	`false`	Die neueste Unterhaltung fortsetzen
`customSystemPrompt`	`string`	`undefined`	Die Standard-Systemaufforderung vollständig ersetzen
`cwd`	`string`	`process.cwd()`	Aktuelles Arbeitsverzeichnis
`disallowedTools`	`string[]`	`[]`	Liste der nicht erlaubten Tool-Namen
`env`	`Dict<string>`	`process.env`	Umgebungsvariablen
`executable`	`'bun' \| 'deno' \| 'node'`	Automatisch erkannt	Zu verwendende JavaScript-Laufzeit
`executableArgs`	`string[]`	`[]`	Argumente, die an die ausführbare Datei übergeben werden
`extraArgs`	`Record<string, string \| null>`	`{}`	Zusätzliche Argumente
`fallbackModel`	`string`	`undefined`	Modell, das verwendet wird, wenn das primäre fehlschlägt
`hooks`	`Partial<Record<HookEvent,` `HookCallbackMatcher[]>>`	`{}`	Hook-Callbacks für Ereignisse
`includePartialMessages`	`boolean`	`false`	Partielle Nachrichtenereignisse einschließen
`maxThinkingTokens`	`number`	`undefined`	Maximale Token für Denkprozess
`maxTurns`	`number`	`undefined`	Maximale Unterhaltungsrunden
`mcpServers`	`Record<string,` `McpServerConfig>`	`{}`	MCP-Server-Konfigurationen
`model`	`string`	Standard aus CLI	Zu verwendendes Claude-Modell
`pathToClaudeCodeExecutable`	`string`	Automatisch erkannt	Pfad zur Claude Code ausführbaren Datei
`permissionMode`	`PermissionMode`	`'default'`	Berechtigungsmodus für die Sitzung
`permissionPromptToolName`	`string`	`undefined`	MCP-Tool-Name für Berechtigungsaufforderungen
`resume`	`string`	`undefined`	Sitzungs-ID zum Fortsetzen
`stderr`	`(data: string) => void`	`undefined`	Callback für stderr-Ausgabe
`strictMcpConfig`	`boolean`	`false`	Strikte MCP-Validierung durchsetzen

`Query`

Schnittstelle, die von der query()-Funktion zurückgegeben wird.

interface Query extends AsyncGenerator<SDKMessage, void> {
  interrupt(): Promise<void>;
  setPermissionMode(mode: PermissionMode): Promise<void>;
}

Methoden

Methode	Beschreibung
`interrupt()`	Unterbricht die Abfrage (nur im Streaming-Eingabemodus verfügbar)
`setPermissionMode()`	Ändert den Berechtigungsmodus (nur im Streaming-Eingabemodus verfügbar)

`PermissionMode`

type PermissionMode = 
  | 'default'           // Standard-Berechtigungsverhalten
  | 'acceptEdits'       // Dateibearbeitungen automatisch akzeptieren
  | 'bypassPermissions' // Alle Berechtigungsprüfungen umgehen
  | 'plan'              // Planungsmodus - keine Ausführung

`CanUseTool`

Benutzerdefinierter Berechtigungsfunktionstyp zur Kontrolle der Tool-Verwendung.

type CanUseTool = (
  toolName: string,
  input: ToolInput,
  options: {
    signal: AbortSignal;
    suggestions?: PermissionUpdate[];
  }
) => Promise<PermissionResult>;

`PermissionResult`

Ergebnis einer Berechtigungsprüfung.

type PermissionResult = 
  | {
      behavior: 'allow';
      updatedInput: ToolInput;
      updatedPermissions?: PermissionUpdate[];
    }
  | {
      behavior: 'deny';
      message: string;
      interrupt?: boolean;
    }

`McpServerConfig`

Konfiguration für MCP-Server.

type McpServerConfig = 
  | McpStdioServerConfig
  | McpSSEServerConfig
  | McpHttpServerConfig
  | McpSdkServerConfigWithInstance;

`McpStdioServerConfig`

type McpStdioServerConfig = {
  type?: 'stdio';
  command: string;
  args?: string[];
  env?: Record<string, string>;
}

`McpSSEServerConfig`

type McpSSEServerConfig = {
  type: 'sse';
  url: string;
  headers?: Record<string, string>;
}

`McpHttpServerConfig`

type McpHttpServerConfig = {
  type: 'http';
  url: string;
  headers?: Record<string, string>;
}

`McpSdkServerConfigWithInstance`

type McpSdkServerConfigWithInstance = {
  type: 'sdk';
  name: string;
  instance: McpServer;
}

Nachrichtentypen

`SDKMessage`

Union-Typ aller möglichen Nachrichten, die von der Abfrage zurückgegeben werden.

type SDKMessage = 
  | SDKAssistantMessage
  | SDKUserMessage
  | SDKUserMessageReplay
  | SDKResultMessage
  | SDKSystemMessage
  | SDKPartialAssistantMessage
  | SDKCompactBoundaryMessage;

`SDKAssistantMessage`

Assistenten-Antwortnachricht.

type SDKAssistantMessage = {
  type: 'assistant';
  uuid: UUID;
  session_id: string;
  message: APIAssistantMessage; // Aus Anthropic SDK
  parent_tool_use_id: string | null;
}

`SDKUserMessage`

Benutzereingabenachricht.

type SDKUserMessage = {
  type: 'user';
  uuid?: UUID;
  session_id: string;
  message: APIUserMessage; // Aus Anthropic SDK
  parent_tool_use_id: string | null;
}

`SDKUserMessageReplay`

Wiedergegebene Benutzernachricht mit erforderlicher UUID.

type SDKUserMessageReplay = {
  type: 'user';
  uuid: UUID;
  session_id: string;
  message: APIUserMessage;
  parent_tool_use_id: string | null;
}

`SDKResultMessage`

Finale Ergebnisnachricht.

type SDKResultMessage = 
  | {
      type: 'result';
      subtype: 'success';
      uuid: UUID;
      session_id: string;
      duration_ms: number;
      duration_api_ms: number;
      is_error: boolean;
      num_turns: number;
      result: string;
      total_cost_usd: number;
      usage: NonNullableUsage;
      permission_denials: SDKPermissionDenial[];
    }
  | {
      type: 'result';
      subtype: 'error_max_turns' | 'error_during_execution';
      uuid: UUID;
      session_id: string;
      duration_ms: number;
      duration_api_ms: number;
      is_error: boolean;
      num_turns: number;
      total_cost_usd: number;
      usage: NonNullableUsage;
      permission_denials: SDKPermissionDenial[];
    }

`SDKSystemMessage`

System-Initialisierungsnachricht.

type SDKSystemMessage = {
  type: 'system';
  subtype: 'init';
  uuid: UUID;
  session_id: string;
  apiKeySource: ApiKeySource;
  cwd: string;
  tools: string[];
  mcp_servers: {
    name: string;
    status: string;
  }[];
  model: string;
  permissionMode: PermissionMode;
  slash_commands: string[];
  output_style: string;
}

`SDKPartialAssistantMessage`

Streaming-Teilnachricht (nur wenn includePartialMessages wahr ist).

type SDKPartialAssistantMessage = {
  type: 'stream_event';
  event: RawMessageStreamEvent; // Aus Anthropic SDK
  parent_tool_use_id: string | null;
  uuid: UUID;
  session_id: string;
}

`SDKCompactBoundaryMessage`

Nachricht, die eine Unterhaltungskompaktierungsgrenze anzeigt.

type SDKCompactBoundaryMessage = {
  type: 'system';
  subtype: 'compact_boundary';
  uuid: UUID;
  session_id: string;
  compact_metadata: {
    trigger: 'manual' | 'auto';
    pre_tokens: number;
  };
}

`SDKPermissionDenial`

Informationen über eine verweigerte Tool-Verwendung.

type SDKPermissionDenial = {
  tool_name: string;
  tool_use_id: string;
  tool_input: ToolInput;
}

Hook-Typen

`HookEvent`

Verfügbare Hook-Ereignisse.

type HookEvent = 
  | 'PreToolUse'
  | 'PostToolUse'
  | 'Notification'
  | 'UserPromptSubmit'
  | 'SessionStart'
  | 'SessionEnd'
  | 'Stop'
  | 'SubagentStop'
  | 'PreCompact';

`HookCallback`

Hook-Callback-Funktionstyp.

type HookCallback = (
  input: HookInput, // Union aller Hook-Eingabetypen
  toolUseID: string | undefined,
  options: { signal: AbortSignal }
) => Promise<HookJSONOutput>;

`HookCallbackMatcher`

Hook-Konfiguration mit optionalem Matcher.

interface HookCallbackMatcher {
  matcher?: string;
  hooks: HookCallback[];
}

`HookInput`

Union-Typ aller Hook-Eingabetypen.

type HookInput = 
  | PreToolUseHookInput
  | PostToolUseHookInput
  | NotificationHookInput
  | UserPromptSubmitHookInput
  | SessionStartHookInput
  | SessionEndHookInput
  | StopHookInput
  | SubagentStopHookInput
  | PreCompactHookInput;

`BaseHookInput`

Basis-Schnittstelle, die alle Hook-Eingabetypen erweitern.

type BaseHookInput = {
  session_id: string;
  transcript_path: string;
  cwd: string;
  permission_mode?: string;
}

`PreToolUseHookInput`

type PreToolUseHookInput = BaseHookInput & {
  hook_event_name: 'PreToolUse';
  tool_name: string;
  tool_input: ToolInput;
}

`PostToolUseHookInput`

type PostToolUseHookInput = BaseHookInput & {
  hook_event_name: 'PostToolUse';
  tool_name: string;
  tool_input: ToolInput;
  tool_response: ToolOutput;
}

`NotificationHookInput`

type NotificationHookInput = BaseHookInput & {
  hook_event_name: 'Notification';
  message: string;
  title?: string;
}

`UserPromptSubmitHookInput`

type UserPromptSubmitHookInput = BaseHookInput & {
  hook_event_name: 'UserPromptSubmit';
  prompt: string;
}

`SessionStartHookInput`

type SessionStartHookInput = BaseHookInput & {
  hook_event_name: 'SessionStart';
  source: 'startup' | 'resume' | 'clear' | 'compact';
}

`SessionEndHookInput`

type SessionEndHookInput = BaseHookInput & {
  hook_event_name: 'SessionEnd';
  reason: 'clear' | 'logout' | 'prompt_input_exit' | 'other';
}

`StopHookInput`

type StopHookInput = BaseHookInput & {
  hook_event_name: 'Stop';
  stop_hook_active: boolean;
}

`SubagentStopHookInput`

type SubagentStopHookInput = BaseHookInput & {
  hook_event_name: 'SubagentStop';
  stop_hook_active: boolean;
}

`PreCompactHookInput`

type PreCompactHookInput = BaseHookInput & {
  hook_event_name: 'PreCompact';
  trigger: 'manual' | 'auto';
  custom_instructions: string | null;
}

`HookJSONOutput`

Hook-Rückgabewert.

type HookJSONOutput = AsyncHookJSONOutput | SyncHookJSONOutput;

`AsyncHookJSONOutput`

type AsyncHookJSONOutput = {
  async: true;
  asyncTimeout?: number;
}

`SyncHookJSONOutput`

type SyncHookJSONOutput = {
  continue?: boolean;
  suppressOutput?: boolean;
  stopReason?: string;
  decision?: 'approve' | 'block';
  systemMessage?: string;
  reason?: string;
  hookSpecificOutput?:
    | {
        hookEventName: 'PreToolUse';
        permissionDecision?: 'allow' | 'deny' | 'ask';
        permissionDecisionReason?: string;
      }
    | {
        hookEventName: 'UserPromptSubmit';
        additionalContext?: string;
      }
    | {
        hookEventName: 'SessionStart';
        additionalContext?: string;
      }
    | {
        hookEventName: 'PostToolUse';
        additionalContext?: string;
      };
}

Tool-Eingabetypen

Dokumentation der Eingabeschemata für alle integrierten Claude Code Tools. Diese Typen werden aus @anthropic/claude-code-sdk exportiert und können für typsichere Tool-Interaktionen verwendet werden.

`ToolInput`

Hinweis: Dies ist ein nur zur Dokumentation dienender Typ für Klarheit. Er repräsentiert die Union aller Tool-Eingabetypen.

type ToolInput = 
  | AgentInput
  | BashInput
  | BashOutputInput
  | FileEditInput
  | FileMultiEditInput
  | FileReadInput
  | FileWriteInput
  | GlobInput
  | GrepInput
  | KillShellInput
  | NotebookEditInput
  | WebFetchInput
  | WebSearchInput
  | TodoWriteInput
  | ExitPlanModeInput
  | ListMcpResourcesInput
  | ReadMcpResourceInput;

Task

Tool-Name: Task

interface AgentInput {
  /**
   * Eine kurze (3-5 Wörter) Beschreibung der Aufgabe
   */
  description: string;
  /**
   * Die Aufgabe, die der Agent ausführen soll
   */
  prompt: string;
  /**
   * Der Typ des spezialisierten Agenten, der für diese Aufgabe verwendet werden soll
   */
  subagent_type: string;
}

Startet einen neuen Agenten zur autonomen Bearbeitung komplexer, mehrstufiger Aufgaben.

Bash

Tool-Name: Bash

interface BashInput {
  /**
   * Der auszuführende Befehl
   */
  command: string;
  /**
   * Optionales Timeout in Millisekunden (max 600000)
   */
  timeout?: number;
  /**
   * Klare, prägnante Beschreibung dessen, was dieser Befehl in 5-10 Wörtern tut
   */
  description?: string;
  /**
   * Auf true setzen, um diesen Befehl im Hintergrund auszuführen
   */
  run_in_background?: boolean;
}

Führt Bash-Befehle in einer persistenten Shell-Sitzung mit optionalem Timeout und Hintergrundausführung aus.

BashOutput

Tool-Name: BashOutput

interface BashOutputInput {
  /**
   * Die ID der Hintergrund-Shell, von der die Ausgabe abgerufen werden soll
   */
  bash_id: string;
  /**
   * Optionaler Regex zum Filtern von Ausgabezeilen
   */
  filter?: string;
}

Ruft Ausgabe von einer laufenden oder abgeschlossenen Hintergrund-Bash-Shell ab.

Edit

Tool-Name: Edit

interface FileEditInput {
  /**
   * Der absolute Pfad zur zu ändernden Datei
   */
  file_path: string;
  /**
   * Der zu ersetzende Text
   */
  old_string: string;
  /**
   * Der Text, durch den ersetzt werden soll (muss sich von old_string unterscheiden)
   */
  new_string: string;
  /**
   * Alle Vorkommen von old_string ersetzen (Standard false)
   */
  replace_all?: boolean;
}

Führt exakte String-Ersetzungen in Dateien durch.

MultiEdit

Tool-Name: MultiEdit

interface FileMultiEditInput {
  /**
   * Der absolute Pfad zur zu ändernden Datei
   */
  file_path: string;
  /**
   * Array von Bearbeitungsoperationen, die sequenziell ausgeführt werden
   */
  edits: Array<{
    /**
     * Der zu ersetzende Text
     */
    old_string: string;
    /**
     * Der Text, durch den ersetzt werden soll
     */
    new_string: string;
    /**
     * Alle Vorkommen ersetzen (Standard false)
     */
    replace_all?: boolean;
  }>;
}

Nimmt mehrere Bearbeitungen an einer einzelnen Datei in einer Operation vor.

Read

Tool-Name: Read

interface FileReadInput {
  /**
   * Der absolute Pfad zur zu lesenden Datei
   */
  file_path: string;
  /**
   * Die Zeilennummer, ab der gelesen werden soll
   */
  offset?: number;
  /**
   * Die Anzahl der zu lesenden Zeilen
   */
  limit?: number;
}

Liest Dateien aus dem lokalen Dateisystem, einschließlich Text, Bilder, PDFs und Jupyter-Notebooks.

Write

Tool-Name: Write

interface FileWriteInput {
  /**
   * Der absolute Pfad zur zu schreibenden Datei
   */
  file_path: string;
  /**
   * Der Inhalt, der in die Datei geschrieben werden soll
   */
  content: string;
}

Schreibt eine Datei in das lokale Dateisystem und überschreibt sie, falls sie existiert.

Glob

Tool-Name: Glob

interface GlobInput {
  /**
   * Das Glob-Muster, gegen das Dateien abgeglichen werden sollen
   */
  pattern: string;
  /**
   * Das Verzeichnis, in dem gesucht werden soll (Standard ist cwd)
   */
  path?: string;
}

Schnelle Dateimuster-Abgleichung, die mit jeder Codebase-Größe funktioniert.

Grep

Tool-Name: Grep

interface GrepInput {
  /**
   * Das reguläre Ausdrucksmuster, nach dem gesucht werden soll
   */
  pattern: string;
  /**
   * Datei oder Verzeichnis, in dem gesucht werden soll (Standard ist cwd)
   */
  path?: string;
  /**
   * Glob-Muster zum Filtern von Dateien (z.B. "*.js")
   */
  glob?: string;
  /**
   * Dateityp zum Suchen (z.B. "js", "py", "rust")
   */
  type?: string;
  /**
   * Ausgabemodus: "content", "files_with_matches" oder "count"
   */
  output_mode?: 'content' | 'files_with_matches' | 'count';
  /**
   * Groß-/Kleinschreibung ignorieren
   */
  '-i'?: boolean;
  /**
   * Zeilennummern anzeigen (für content-Modus)
   */
  '-n'?: boolean;
  /**
   * Zeilen vor jedem Treffer anzeigen
   */
  '-B'?: number;
  /**
   * Zeilen nach jedem Treffer anzeigen
   */
  '-A'?: number;
  /**
   * Zeilen vor und nach jedem Treffer anzeigen
   */
  '-C'?: number;
  /**
   * Ausgabe auf erste N Zeilen/Einträge begrenzen
   */
  head_limit?: number;
  /**
   * Mehrzeilenmodus aktivieren
   */
  multiline?: boolean;
}

Mächtiges Suchwerkzeug basierend auf ripgrep mit Regex-Unterstützung.

KillBash

Tool-Name: KillBash

interface KillShellInput {
  /**
   * Die ID der zu beendenden Hintergrund-Shell
   */
  shell_id: string;
}

Beendet eine laufende Hintergrund-Bash-Shell anhand ihrer ID.

NotebookEdit

Tool-Name: NotebookEdit

interface NotebookEditInput {
  /**
   * Der absolute Pfad zur Jupyter-Notebook-Datei
   */
  notebook_path: string;
  /**
   * Die ID der zu bearbeitenden Zelle
   */
  cell_id?: string;
  /**
   * Der neue Quellcode für die Zelle
   */
  new_source: string;
  /**
   * Der Typ der Zelle (code oder markdown)
   */
  cell_type?: 'code' | 'markdown';
  /**
   * Der Typ der Bearbeitung (replace, insert, delete)
   */
  edit_mode?: 'replace' | 'insert' | 'delete';
}

Bearbeitet Zellen in Jupyter-Notebook-Dateien.

WebFetch

Tool-Name: WebFetch

interface WebFetchInput {
  /**
   * Die URL, von der Inhalte abgerufen werden sollen
   */
  url: string;
  /**
   * Die Aufforderung, die auf den abgerufenen Inhalt angewendet werden soll
   */
  prompt: string;
}

Ruft Inhalte von einer URL ab und verarbeitet sie mit einem KI-Modell.

WebSearch

Tool-Name: WebSearch

interface WebSearchInput {
  /**
   * Die zu verwendende Suchanfrage
   */
  query: string;
  /**
   * Nur Ergebnisse von diesen Domains einschließen
   */
  allowed_domains?: string[];
  /**
   * Niemals Ergebnisse von diesen Domains einschließen
   */
  blocked_domains?: string[];
}

Durchsucht das Web und gibt formatierte Ergebnisse zurück.

TodoWrite

Tool-Name: TodoWrite

interface TodoWriteInput {
  /**
   * Die aktualisierte Todo-Liste
   */
  todos: Array<{
    /**
     * Die Aufgabenbeschreibung
     */
    content: string;
    /**
     * Der Aufgabenstatus
     */
    status: 'pending' | 'in_progress' | 'completed';
    /**
     * Aktive Form der Aufgabenbeschreibung
     */
    activeForm: string;
  }>;
}

Erstellt und verwaltet eine strukturierte Aufgabenliste zur Fortschrittsverfolgung.

ExitPlanMode

Tool-Name: ExitPlanMode

interface ExitPlanModeInput {
  /**
   * Der Plan, der vom Benutzer zur Genehmigung ausgeführt werden soll
   */
  plan: string;
}

Verlässt den Planungsmodus und fordert den Benutzer auf, den Plan zu genehmigen.

ListMcpResources

Tool-Name: ListMcpResources

interface ListMcpResourcesInput {
  /**
   * Optionaler Servername zum Filtern von Ressourcen
   */
  server?: string;
}

Listet verfügbare MCP-Ressourcen von verbundenen Servern auf.

ReadMcpResource

Tool-Name: ReadMcpResource

interface ReadMcpResourceInput {
  /**
   * Der MCP-Servername
   */
  server: string;
  /**
   * Die zu lesende Ressourcen-URI
   */
  uri: string;
}

Liest eine spezifische MCP-Ressource von einem Server.

Tool-Ausgabetypen

Dokumentation der Ausgabeschemata für alle integrierten Claude Code Tools. Diese Typen repräsentieren die tatsächlichen Antwortdaten, die von jedem Tool zurückgegeben werden.

`ToolOutput`

Hinweis: Dies ist ein nur zur Dokumentation dienender Typ für Klarheit. Er repräsentiert die Union aller Tool-Ausgabetypen.

type ToolOutput = 
  | TaskOutput
  | BashOutput
  | BashOutputToolOutput
  | EditOutput
  | MultiEditOutput
  | ReadOutput
  | WriteOutput
  | GlobOutput
  | GrepOutput
  | KillBashOutput
  | NotebookEditOutput
  | WebFetchOutput
  | WebSearchOutput
  | TodoWriteOutput
  | ExitPlanModeOutput
  | ListMcpResourcesOutput
  | ReadMcpResourceOutput;

Task

Tool-Name: Task

interface TaskOutput {
  /**
   * Finale Ergebnisnachricht vom Subagenten
   */
  result: string;
  /**
   * Token-Nutzungsstatistiken
   */
  usage?: {
    input_tokens: number;
    output_tokens: number;
    cache_creation_input_tokens?: number;
    cache_read_input_tokens?: number;
  };
  /**
   * Gesamtkosten in USD
   */
  total_cost_usd?: number;
  /**
   * Ausführungsdauer in Millisekunden
   */
  duration_ms?: number;
}

Gibt das finale Ergebnis vom Subagenten nach Abschluss der delegierten Aufgabe zurück.

Bash

Tool-Name: Bash

interface BashOutput {
  /**
   * Kombinierte stdout- und stderr-Ausgabe
   */
  output: string;
  /**
   * Exit-Code des Befehls
   */
  exitCode: number;
  /**
   * Ob der Befehl aufgrund eines Timeouts beendet wurde
   */
  killed?: boolean;
  /**
   * Shell-ID für Hintergrundprozesse
   */
  shellId?: string;
}

Gibt Befehlsausgabe mit Exit-Status zurück. Hintergrundbefehle geben sofort mit einer shellId zurück.

BashOutput

Tool-Name: BashOutput

interface BashOutputToolOutput {
  /**
   * Neue Ausgabe seit der letzten Überprüfung
   */
  output: string;
  /**
   * Aktueller Shell-Status
   */
  status: 'running' | 'completed' | 'failed';
  /**
   * Exit-Code (wenn abgeschlossen)
   */
  exitCode?: number;
}

Gibt inkrementelle Ausgabe von Hintergrund-Shells zurück.

Edit

Tool-Name: Edit

interface EditOutput {
  /**
   * Bestätigungsnachricht
   */
  message: string;
  /**
   * Anzahl der vorgenommenen Ersetzungen
   */
  replacements: number;
  /**
   * Dateipfad, der bearbeitet wurde
   */
  file_path: string;
}

Gibt Bestätigung erfolgreicher Bearbeitungen mit Ersetzungsanzahl zurück.

MultiEdit

Tool-Name: MultiEdit

interface MultiEditOutput {
  /**
   * Erfolgsnachricht
   */
  message: string;
  /**
   * Gesamtanzahl der angewendeten Bearbeitungen
   */
  edits_applied: number;
  /**
   * Dateipfad, der bearbeitet wurde
   */
  file_path: string;
}

Gibt Bestätigung nach Anwendung aller Bearbeitungen sequenziell zurück.

Read

Tool-Name: Read

type ReadOutput = 
  | TextFileOutput
  | ImageFileOutput
  | PDFFileOutput
  | NotebookFileOutput;

interface TextFileOutput {
  /**
   * Dateiinhalt mit Zeilennummern
   */
  content: string;
  /**
   * Gesamtanzahl der Zeilen in der Datei
   */
  total_lines: number;
  /**
   * Tatsächlich zurückgegebene Zeilen
   */
  lines_returned: number;
}

interface ImageFileOutput {
  /**
   * Base64-kodierte Bilddaten
   */
  image: string;
  /**
   * Bild-MIME-Typ
   */
  mime_type: string;
  /**
   * Dateigröße in Bytes
   */
  file_size: number;
}

interface PDFFileOutput {
  /**
   * Array von Seiteninhalten
   */
  pages: Array<{
    page_number: number;
    text?: string;
    images?: Array<{
      image: string;
      mime_type: string;
    }>;
  }>;
  /**
   * Gesamtanzahl der Seiten
   */
  total_pages: number;
}

interface NotebookFileOutput {
  /**
   * Jupyter-Notebook-Zellen
   */
  cells: Array<{
    cell_type: 'code' | 'markdown';
    source: string;
    outputs?: any[];
    execution_count?: number;
  }>;
  /**
   * Notebook-Metadaten
   */
  metadata?: Record<string, any>;
}

Gibt Dateiinhalt in einem für den Dateityp geeigneten Format zurück.

Write

Tool-Name: Write

interface WriteOutput {
  /**
   * Erfolgsnachricht
   */
  message: string;
  /**
   * Anzahl der geschriebenen Bytes
   */
  bytes_written: number;
  /**
   * Dateipfad, der geschrieben wurde
   */
  file_path: string;
}

Gibt Bestätigung nach erfolgreichem Schreiben der Datei zurück.

Glob

Tool-Name: Glob

interface GlobOutput {
  /**
   * Array übereinstimmender Dateipfade
   */
  matches: string[];
  /**
   * Anzahl gefundener Übereinstimmungen
   */
  count: number;
  /**
   * Verwendetes Suchverzeichnis
   */
  search_path: string;
}

Gibt Dateipfade zurück, die dem Glob-Muster entsprechen, sortiert nach Änderungszeit.

Grep

Tool-Name: Grep

type GrepOutput = 
  | GrepContentOutput
  | GrepFilesOutput
  | GrepCountOutput;

interface GrepContentOutput {
  /**
   * Übereinstimmende Zeilen mit Kontext
   */
  matches: Array<{
    file: string;
    line_number?: number;
    line: string;
    before_context?: string[];
    after_context?: string[];
  }>;
  /**
   * Gesamtanzahl der Übereinstimmungen
   */
  total_matches: number;
}

interface GrepFilesOutput {
  /**
   * Dateien mit Übereinstimmungen
   */
  files: string[];
  /**
   * Anzahl der Dateien mit Übereinstimmungen
   */
  count: number;
}

interface GrepCountOutput {
  /**
   * Übereinstimmungsanzahl pro Datei
   */
  counts: Array<{
    file: string;
    count: number;
  }>;
  /**
   * Gesamtübereinstimmungen über alle Dateien
   */
  total: number;
}

Gibt Suchergebnisse in dem durch output_mode spezifizierten Format zurück.

KillBash

Tool-Name: KillBash

interface KillBashOutput {
  /**
   * Erfolgsnachricht
   */
  message: string;
  /**
   * ID der beendeten Shell
   */
  shell_id: string;
}

Gibt Bestätigung nach Beendigung der Hintergrund-Shell zurück.

NotebookEdit

Tool-Name: NotebookEdit

interface NotebookEditOutput {
  /**
   * Erfolgsnachricht
   */
  message: string;
  /**
   * Typ der durchgeführten Bearbeitung
   */
  edit_type: 'replaced' | 'inserted' | 'deleted';
  /**
   * Zellen-ID, die betroffen war
   */
  cell_id?: string;
  /**
   * Gesamtzellen im Notebook nach der Bearbeitung
   */
  total_cells: number;
}

Gibt Bestätigung nach Änderung des Jupyter-Notebooks zurück.

WebFetch

Tool-Name: WebFetch

interface WebFetchOutput {
  /**
   * Antwort des KI-Modells auf die Aufforderung
   */
  response: string;
  /**
   * URL, die abgerufen wurde
   */
  url: string;
  /**
   * Finale URL nach Weiterleitungen
   */
  final_url?: string;
  /**
   * HTTP-Statuscode
   */
  status_code?: number;
}

Gibt die KI-Analyse des abgerufenen Webinhalts zurück.

WebSearch

Tool-Name: WebSearch

interface WebSearchOutput {
  /**
   * Suchergebnisse
   */
  results: Array<{
    title: string;
    url: string;
    snippet: string;
    /**
     * Zusätzliche Metadaten, falls verfügbar
     */
    metadata?: Record<string, any>;
  }>;
  /**
   * Gesamtanzahl der Ergebnisse
   */
  total_results: number;
  /**
   * Die Anfrage, die gesucht wurde
   */
  query: string;
}

Gibt formatierte Suchergebnisse aus dem Web zurück.

TodoWrite

Tool-Name: TodoWrite

interface TodoWriteOutput {
  /**
   * Erfolgsnachricht
   */
  message: string;
  /**
   * Aktuelle Todo-Statistiken
   */
  stats: {
    total: number;
    pending: number;
    in_progress: number;
    completed: number;
  };
}

Gibt Bestätigung mit aktuellen Aufgabenstatistiken zurück.

ExitPlanMode

Tool-Name: ExitPlanMode

interface ExitPlanModeOutput {
  /**
   * Bestätigungsnachricht
   */
  message: string;
  /**
   * Ob der Benutzer den Plan genehmigt hat
   */
  approved?: boolean;
}

Gibt Bestätigung nach Verlassen des Planmodus zurück.

ListMcpResources

Tool-Name: ListMcpResources

interface ListMcpResourcesOutput {
  /**
   * Verfügbare Ressourcen
   */
  resources: Array<{
    uri: string;
    name: string;
    description?: string;
    mimeType?: string;
    server: string;
  }>;
  /**
   * Gesamtanzahl der Ressourcen
   */
  total: number;
}

Gibt Liste verfügbarer MCP-Ressourcen zurück.

ReadMcpResource

Tool-Name: ReadMcpResource

interface ReadMcpResourceOutput {
  /**
   * Ressourceninhalte
   */
  contents: Array<{
    uri: string;
    mimeType?: string;
    text?: string;
    blob?: string;
  }>;
  /**
   * Server, der die Ressource bereitgestellt hat
   */
  server: string;
}

Gibt die Inhalte der angeforderten MCP-Ressource zurück.

Berechtigungstypen

`PermissionUpdate`

Operationen zur Aktualisierung von Berechtigungen.

type PermissionUpdate = 
  | {
      type: 'addRules';
      rules: PermissionRuleValue[];
      behavior: PermissionBehavior;
      destination: PermissionUpdateDestination;
    }
  | {
      type: 'replaceRules';
      rules: PermissionRuleValue[];
      behavior: PermissionBehavior;
      destination: PermissionUpdateDestination;
    }
  | {
      type: 'removeRules';
      rules: PermissionRuleValue[];
      behavior: PermissionBehavior;
      destination: PermissionUpdateDestination;
    }
  | {
      type: 'setMode';
      mode: PermissionMode;
      destination: PermissionUpdateDestination;
    }
  | {
      type: 'addDirectories';
      directories: string[];
      destination: PermissionUpdateDestination;
    }
  | {
      type: 'removeDirectories';
      directories: string[];
      destination: PermissionUpdateDestination;
    }

`PermissionBehavior`

type PermissionBehavior = 'allow' | 'deny' | 'ask';

`PermissionUpdateDestination`

type PermissionUpdateDestination = 
  | 'userSettings'     // Globale Benutzereinstellungen
  | 'projectSettings'  // Pro-Verzeichnis-Projekteinstellungen
  | 'localSettings'    // Gitignorierte lokale Einstellungen
  | 'session'          // Nur aktuelle Sitzung

`PermissionRuleValue`

type PermissionRuleValue = {
  toolName: string;
  ruleContent?: string;
}

Andere Typen

`ApiKeySource`

type ApiKeySource = 'user' | 'project' | 'org' | 'temporary';

`ConfigScope`

type ConfigScope = 'local' | 'user' | 'project';

`NonNullableUsage`

Eine Version von Usage mit allen nullable Feldern als non-nullable.

type NonNullableUsage = {
  [K in keyof Usage]: NonNullable<Usage[K]>;
}

`Usage`

Token-Nutzungsstatistiken (aus @anthropic-ai/sdk).

type Usage = {
  input_tokens: number | null;
  output_tokens: number | null;
  cache_creation_input_tokens?: number | null;
  cache_read_input_tokens?: number | null;
}

`CallToolResult`

MCP-Tool-Ergebnistyp (aus @modelcontextprotocol/sdk/types.js).

type CallToolResult = {
  content: Array<{
    type: 'text' | 'image' | 'resource';
    // Zusätz liche Felder variieren je nach Typ
  }>;
  isError?: boolean;
}

`AbortError`

Benutzerdefinierte Fehlerklasse für Abbruchoperationen.

class AbortError extends Error {}

Siehe auch

TypeScript SDK Leitfaden - Tutorial und Beispiele
SDK Übersicht - Allgemeine SDK-Konzepte
Python SDK Referenz - Python SDK Dokumentation
CLI Referenz - Befehlszeilenschnittstelle
Häufige Arbeitsabläufe - Schritt-für-Schritt-Anleitungen

Erste Schritte

Mit Claude Code entwickeln

Claude Code SDK

Bereitstellung

Verwaltung

Konfiguration

Referenz

Ressourcen

​Funktionen

​query()

​Parameter

​Rückgabe

​tool()

​Parameter

​createSdkMcpServer()

​Parameter

​Typen

​Options

​Query

​Methoden

​PermissionMode

​CanUseTool

​PermissionResult

​McpServerConfig

​McpStdioServerConfig

​McpSSEServerConfig

​McpHttpServerConfig

​McpSdkServerConfigWithInstance

​Nachrichtentypen

​SDKMessage

​SDKAssistantMessage

​SDKUserMessage

​SDKUserMessageReplay

​SDKResultMessage

​SDKSystemMessage

​SDKPartialAssistantMessage

​SDKCompactBoundaryMessage

​SDKPermissionDenial

​Hook-Typen

​HookEvent

​HookCallback

​HookCallbackMatcher

​HookInput

​BaseHookInput

​PreToolUseHookInput

​PostToolUseHookInput

​NotificationHookInput

​UserPromptSubmitHookInput

​SessionStartHookInput

​SessionEndHookInput

​StopHookInput

​SubagentStopHookInput

​PreCompactHookInput

​HookJSONOutput

​AsyncHookJSONOutput

​SyncHookJSONOutput

​Tool-Eingabetypen

​ToolInput

​Task

​Bash

​BashOutput

​Edit

​MultiEdit

​Read

​Write

​Glob

​Grep

​KillBash

​NotebookEdit

​WebFetch

​WebSearch

​TodoWrite

​ExitPlanMode

​ListMcpResources

​ReadMcpResource

​Tool-Ausgabetypen

​ToolOutput

​Task

​Bash

​BashOutput

Funktionen

`query()`

Parameter

Rückgabe

`tool()`

Parameter

`createSdkMcpServer()`

Parameter

Typen

`Options`

`Query`

Methoden

`PermissionMode`

`CanUseTool`

`PermissionResult`

`McpServerConfig`

`McpStdioServerConfig`

`McpSSEServerConfig`

`McpHttpServerConfig`

`McpSdkServerConfigWithInstance`

Nachrichtentypen

`SDKMessage`

`SDKAssistantMessage`

`SDKUserMessage`

`SDKUserMessageReplay`

`SDKResultMessage`

`SDKSystemMessage`

`SDKPartialAssistantMessage`

`SDKCompactBoundaryMessage`

`SDKPermissionDenial`

Hook-Typen

`HookEvent`

`HookCallback`

`HookCallbackMatcher`

`HookInput`

`BaseHookInput`

`PreToolUseHookInput`

`PostToolUseHookInput`

`NotificationHookInput`

`UserPromptSubmitHookInput`

`SessionStartHookInput`

`SessionEndHookInput`

`StopHookInput`

`SubagentStopHookInput`

`PreCompactHookInput`

`HookJSONOutput`

`AsyncHookJSONOutput`

`SyncHookJSONOutput`

Tool-Eingabetypen

`ToolInput`

Task

Bash

BashOutput

Edit

MultiEdit

Read

Write

Glob

Grep

KillBash

NotebookEdit

WebFetch

WebSearch

TodoWrite

ExitPlanMode

ListMcpResources

ReadMcpResource

Tool-Ausgabetypen

`ToolOutput`

Task

Bash

BashOutput

Edit

MultiEdit

Read

Write

Glob

Grep

KillBash

NotebookEdit