@anthropic-ai/claude-code 1.0.84 → 1.0.85

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@anthropic-ai/claude-code",
-  "version": "1.0.84",
+  "version": "1.0.85",
   "main": "sdk.mjs",
   "types": "sdk.d.ts",
   "bin": {

package/sdk.d.ts

@@ -31,6 +31,87 @@ export type PermissionResult = {
 export type CanUseTool = (toolName: string, input: Record<string, unknown>, options: {
     signal: AbortSignal;
 }) => Promise<PermissionResult>;
+export declare const HOOK_EVENTS: readonly ["PreToolUse", "PostToolUse", "Notification", "UserPromptSubmit", "SessionStart", "SessionEnd", "Stop", "SubagentStop", "PreCompact"];
+export type HookEvent = (typeof HOOK_EVENTS)[number];
+export type HookCallback = (input: HookInput, toolUseID: string | undefined, options: {
+    signal: AbortSignal;
+}) => Promise<HookJSONOutput>;
+export interface HookCallbackMatcher {
+    matcher?: string;
+    hooks: HookCallback[];
+}
+export type BaseHookInput = {
+    session_id: string;
+    transcript_path: string;
+    cwd: string;
+};
+export type PreToolUseHookInput = BaseHookInput & {
+    hook_event_name: 'PreToolUse';
+    tool_name: string;
+    tool_input: unknown;
+};
+export type PostToolUseHookInput = BaseHookInput & {
+    hook_event_name: 'PostToolUse';
+    tool_name: string;
+    tool_input: unknown;
+    tool_response: unknown;
+};
+export type NotificationHookInput = BaseHookInput & {
+    hook_event_name: 'Notification';
+    message: string;
+    title?: string;
+};
+export type UserPromptSubmitHookInput = BaseHookInput & {
+    hook_event_name: 'UserPromptSubmit';
+    prompt: string;
+};
+export type SessionStartHookInput = BaseHookInput & {
+    hook_event_name: 'SessionStart';
+    source: 'startup' | 'resume' | 'clear' | 'compact';
+};
+export type StopHookInput = BaseHookInput & {
+    hook_event_name: 'Stop';
+    stop_hook_active: boolean;
+};
+export type SubagentStopHookInput = BaseHookInput & {
+    hook_event_name: 'SubagentStop';
+    stop_hook_active: boolean;
+};
+export type PreCompactHookInput = BaseHookInput & {
+    hook_event_name: 'PreCompact';
+    trigger: 'manual' | 'auto';
+    custom_instructions: string | null;
+};
+export declare const EXIT_REASONS: string[];
+export type ExitReason = (typeof EXIT_REASONS)[number];
+export type SessionEndHookInput = BaseHookInput & {
+    hook_event_name: 'SessionEnd';
+    reason: ExitReason;
+};
+export type HookInput = PreToolUseHookInput | PostToolUseHookInput | NotificationHookInput | UserPromptSubmitHookInput | SessionStartHookInput | SessionEndHookInput | StopHookInput | SubagentStopHookInput | PreCompactHookInput;
+export interface HookJSONOutput {
+    continue?: boolean;
+    suppressOutput?: boolean;
+    stopReason?: string;
+    decision?: 'approve' | 'block';
+    systemMessage?: string;
+    permissionDecision?: 'allow' | 'deny' | 'ask';
+    reason?: string;
+    hookSpecificOutput?: {
+        hookEventName: 'PreToolUse';
+        permissionDecision?: 'allow' | 'deny' | 'ask';
+        permissionDecisionReason?: string;
+    } | {
+        hookEventName: 'UserPromptSubmit';
+        additionalContext?: string;
+    } | {
+        hookEventName: 'SessionStart';
+        additionalContext?: string;
+    } | {
+        hookEventName: 'PostToolUse';
+        additionalContext?: string;
+    };
+}
 export type Options = {
     abortController?: AbortController;
     additionalDirectories?: string[];
@@ -45,6 +126,7 @@ export type Options = {
     executable?: 'bun' | 'deno' | 'node';
     executableArgs?: string[];
     fallbackModel?: string;
+    hooks?: Partial<Record<HookEvent, HookCallbackMatcher[]>>;
     maxThinkingTokens?: number;
     maxTurns?: number;
     mcpServers?: Record<string, McpServerConfig>;
@@ -112,6 +194,7 @@ export type SDKSystemMessage = {
     model: string;
     permissionMode: PermissionMode;
     slash_commands: string[];
+    output_style: string;
 };
 export type SDKMessage = SDKAssistantMessage | SDKUserMessage | SDKResultMessage | SDKSystemMessage;
 export interface Query extends AsyncGenerator<SDKMessage, void> {
@@ -120,6 +203,11 @@ export interface Query extends AsyncGenerator<SDKMessage, void> {
      * Only supported when streaming input is used.
      */
     interrupt(): Promise<void>;
+    /**
+     * Sets the permission mode.
+     * Only supported when streaming input is used.
+     */
+    setPermissionMode(mode: PermissionMode): Promise<void>;
 }
 /**
  * Query Claude Code

package/sdk.mjs

@@ -2,7 +2,7 @@
 
 // (c) Anthropic PBC. All rights reserved. Use is subject to Anthropic's Commercial Terms of Service (https://www.anthropic.com/legal/commercial-terms).
 
-// Version: 1.0.84
+// Version: 1.0.85
 
 // Want to see the unminified source? We're hiring!
 // https://job-boards.greenhouse.io/anthropic/jobs/4816199008
@@ -106,27 +106,28 @@ function query({
   prompt,
   options: {
     abortController = createAbortController(),
+    additionalDirectories = [],
     allowedTools = [],
     appendSystemPrompt,
+    canUseTool,
+    continue: continueConversation,
     customSystemPrompt,
     cwd,
     disallowedTools = [],
+    env,
     executable = isRunningWithBun() ? "bun" : "node",
     executableArgs = [],
+    fallbackModel,
+    hooks,
     maxTurns,
     mcpServers,
+    model,
     pathToClaudeCodeExecutable,
     permissionMode = "default",
     permissionPromptToolName,
-    canUseTool,
-    continue: continueConversation,
     resume,
-    model,
-    fallbackModel,
-    strictMcpConfig,
     stderr,
-    env,
-    additionalDirectories = []
+    strictMcpConfig
   } = {}
 }) {
   if (!env) {
@@ -242,7 +243,7 @@ function query({
       }
     });
   });
-  const query2 = new Query(childStdin, child.stdout, processExitPromise, canUseTool);
+  const query2 = new Query(childStdin, child.stdout, processExitPromise, canUseTool, hooks);
   child.on("error", (error) => {
     if (abortController.signal.aborted) {
       query2.setError(new AbortError("Claude Code process aborted by user"));
@@ -262,16 +263,20 @@ class Query {
   childStdout;
   processExitPromise;
   canUseTool;
+  hooks;
   pendingControlResponses = new Map;
   sdkMessages;
   inputStream = new Stream;
   intialization;
   cancelControllers = new Map;
-  constructor(childStdin, childStdout, processExitPromise, canUseTool) {
+  hookCallbacks = new Map;
+  nextCallbackId = 0;
+  constructor(childStdin, childStdout, processExitPromise, canUseTool, hooks) {
     this.childStdin = childStdin;
     this.childStdout = childStdout;
     this.processExitPromise = processExitPromise;
     this.canUseTool = canUseTool;
+    this.hooks = hooks;
     this.readMessages();
     this.sdkMessages = this.readSdkMessages();
     if (this.childStdin) {
@@ -371,6 +376,9 @@ class Query {
       return this.canUseTool(request.request.tool_name, request.request.input, {
         signal
       });
+    } else if (request.request.subtype === "hook_callback") {
+      const result = await this.handleHookCallbacks(request.request.callback_id, request.request.input, request.request.tool_use_id, signal);
+      return result;
     }
     throw new Error("Unsupported control request subtype: " + request.request.subtype);
   }
@@ -383,8 +391,29 @@ class Query {
     if (!this.childStdin) {
       throw new Error("Cannot initialize without child stdin");
     }
+    let hooks;
+    if (this.hooks) {
+      hooks = {};
+      for (const [event, matchers] of Object.entries(this.hooks)) {
+        if (matchers.length > 0) {
+          hooks[event] = matchers.map((matcher) => {
+            const callbackIds = [];
+            for (const callback of matcher.hooks) {
+              const callbackId = `hook_${this.nextCallbackId++}`;
+              this.hookCallbacks.set(callbackId, callback);
+              callbackIds.push(callbackId);
+            }
+            return {
+              matcher: matcher.matcher,
+              hookCallbackIds: callbackIds
+            };
+          });
+        }
+      }
+    }
     const initRequest = {
-      subtype: "initialize"
+      subtype: "initialize",
+      hooks
     };
     const response = await this.request(initRequest, this.childStdin);
     return response.response;
@@ -397,6 +426,15 @@ class Query {
       subtype: "interrupt"
     }, this.childStdin);
   }
+  async setPermissionMode(mode) {
+    if (!this.childStdin) {
+      throw new Error("setPermissionMode requires --input-format stream-json");
+    }
+    await this.request({
+      subtype: "set_permission_mode",
+      mode
+    }, this.childStdin);
+  }
   request(request, childStdin) {
     const requestId = Math.random().toString(36).substring(2, 15);
     const sdkRequest = {
@@ -422,6 +460,15 @@ class Query {
     }
     return (await this.intialization).commands;
   }
+  handleHookCallbacks(callbackId, input, toolUseID, abortSignal) {
+    const callback = this.hookCallbacks.get(callbackId);
+    if (!callback) {
+      throw new Error(`No hook callback found for ID: ${callbackId}`);
+    }
+    return callback(input, toolUseID, {
+      signal: abortSignal
+    });
+  }
 }
 async function streamToStdin(stream, stdin, abortController) {
   for await (const message of stream) {