@anthropic-ai/claude-code 1.0.83 → 1.0.85

package/package.json

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

package/sdk.d.ts

@@ -1,171 +1,214 @@
-import type {
-  Message as APIAssistantMessage,
-  MessageParam as APIUserMessage,
-  Usage,
-} from '@anthropic-ai/sdk/resources/index.mjs'
-
+import type { Message as APIAssistantMessage, MessageParam as APIUserMessage, Usage } from '@anthropic-ai/sdk/resources/index.mjs';
 export type NonNullableUsage = {
-  [K in keyof Usage]: NonNullable<Usage[K]>
-}
-
-export type ApiKeySource = 'user' | 'project' | 'org' | 'temporary'
-
-export type ConfigScope = 'local' | 'user' | 'project'
-
+    [K in keyof Usage]: NonNullable<Usage[K]>;
+};
+export type ApiKeySource = 'user' | 'project' | 'org' | 'temporary';
+export type ConfigScope = 'local' | 'user' | 'project';
 export type McpStdioServerConfig = {
-  type?: 'stdio' // Optional for backwards compatibility
-  command: string
-  args?: string[]
-  env?: Record<string, string>
-}
-
+    type?: 'stdio';
+    command: string;
+    args?: string[];
+    env?: Record<string, string>;
+};
 export type McpSSEServerConfig = {
-  type: 'sse'
-  url: string
-  headers?: Record<string, string>
-}
-
+    type: 'sse';
+    url: string;
+    headers?: Record<string, string>;
+};
 export type McpHttpServerConfig = {
-  type: 'http'
-  url: string
-  headers?: Record<string, string>
+    type: 'http';
+    url: string;
+    headers?: Record<string, string>;
+};
+export type McpServerConfig = McpStdioServerConfig | McpSSEServerConfig | McpHttpServerConfig;
+export type PermissionResult = {
+    behavior: 'allow';
+    updatedInput: Record<string, unknown>;
+} | {
+    behavior: 'deny';
+    message: string;
+};
+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 McpServerConfig =
-  | McpStdioServerConfig
-  | McpSSEServerConfig
-  | McpHttpServerConfig
-
-export type PermissionResult =
-  | {
-      behavior: 'allow'
-      updatedInput: Record<string, unknown>
-    }
-  | {
-      behavior: 'deny'
-      message: string
-    }
-
-export type CanUseTool = (
-  toolName: string,
-  input: Record<string, unknown>,
-  options: {
-    // Signaled if the operation should be aborted
-    signal: AbortSignal
-  },
-) => Promise<PermissionResult>
-
-export type Options = {
-  abortController?: AbortController
-  allowedTools?: string[]
-  appendSystemPrompt?: string
-  customSystemPrompt?: string
-  cwd?: string
-  disallowedTools?: string[]
-  executable?: 'bun' | 'deno' | 'node'
-  executableArgs?: string[]
-  maxThinkingTokens?: number
-  maxTurns?: number
-  mcpServers?: Record<string, McpServerConfig>
-  pathToClaudeCodeExecutable?: string
-  permissionMode?: PermissionMode
-  permissionPromptToolName?: string
-  continue?: boolean
-  resume?: string
-  model?: string
-  fallbackModel?: string
-  stderr?: (data: string) => void
-  canUseTool?: CanUseTool
+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 PermissionMode =
-  | 'default'
-  | 'acceptEdits'
-  | 'bypassPermissions'
-  | 'plan'
-
+export type Options = {
+    abortController?: AbortController;
+    additionalDirectories?: string[];
+    allowedTools?: string[];
+    appendSystemPrompt?: string;
+    canUseTool?: CanUseTool;
+    continue?: boolean;
+    customSystemPrompt?: string;
+    cwd?: string;
+    disallowedTools?: string[];
+    env?: Dict<string>;
+    executable?: 'bun' | 'deno' | 'node';
+    executableArgs?: string[];
+    fallbackModel?: string;
+    hooks?: Partial<Record<HookEvent, HookCallbackMatcher[]>>;
+    maxThinkingTokens?: number;
+    maxTurns?: number;
+    mcpServers?: Record<string, McpServerConfig>;
+    model?: string;
+    pathToClaudeCodeExecutable?: string;
+    permissionMode?: PermissionMode;
+    permissionPromptToolName?: string;
+    resume?: string;
+    stderr?: (data: string) => void;
+    strictMcpConfig?: boolean;
+};
+export type PermissionMode = 'default' | 'acceptEdits' | 'bypassPermissions' | 'plan';
 export type SDKUserMessage = {
-  type: 'user'
-  message: APIUserMessage
-  parent_tool_use_id: string | null
-  session_id: string
-}
-
+    type: 'user';
+    message: APIUserMessage;
+    parent_tool_use_id: string | null;
+    session_id: string;
+};
 export type SDKAssistantMessage = {
-  type: 'assistant'
-  message: APIAssistantMessage
-  parent_tool_use_id: string | null
-  session_id: string
-}
-
+    type: 'assistant';
+    message: APIAssistantMessage;
+    parent_tool_use_id: string | null;
+    session_id: string;
+};
 export type SDKPermissionDenial = {
-  tool_name: string
-  tool_use_id: string
-  tool_input: Record<string, unknown>
-}
-
-export type SDKResultMessage =
-  | {
-      type: 'result'
-      subtype: 'success'
-      duration_ms: number
-      duration_api_ms: number
-      is_error: boolean
-      num_turns: number
-      result: string
-      session_id: string
-      total_cost_usd: number
-      usage: NonNullableUsage
-      permission_denials: SDKPermissionDenial[]
-    }
-  | {
-      type: 'result'
-      subtype: 'error_max_turns' | 'error_during_execution'
-      duration_ms: number
-      duration_api_ms: number
-      is_error: boolean
-      num_turns: number
-      session_id: string
-      total_cost_usd: number
-      usage: NonNullableUsage
-      permission_denials: SDKPermissionDenial[]
-    }
-
+    tool_name: string;
+    tool_use_id: string;
+    tool_input: Record<string, unknown>;
+};
+export type SDKResultMessage = {
+    type: 'result';
+    subtype: 'success';
+    duration_ms: number;
+    duration_api_ms: number;
+    is_error: boolean;
+    num_turns: number;
+    result: string;
+    session_id: string;
+    total_cost_usd: number;
+    usage: NonNullableUsage;
+    permission_denials: SDKPermissionDenial[];
+} | {
+    type: 'result';
+    subtype: 'error_max_turns' | 'error_during_execution';
+    duration_ms: number;
+    duration_api_ms: number;
+    is_error: boolean;
+    num_turns: number;
+    session_id: string;
+    total_cost_usd: number;
+    usage: NonNullableUsage;
+    permission_denials: SDKPermissionDenial[];
+};
 export type SDKSystemMessage = {
-  type: 'system'
-  subtype: 'init'
-  apiKeySource: ApiKeySource
-  cwd: string
-  session_id: string
-  tools: string[]
-  mcp_servers: {
-    name: string
-    status: string
-  }[]
-  model: string
-  permissionMode: PermissionMode
-  slash_commands: string[]
-}
-
-export type SDKMessage =
-  | SDKAssistantMessage
-  | SDKUserMessage
-  | SDKResultMessage
-  | SDKSystemMessage
-
-type Props = {
-  prompt: string | AsyncIterable<SDKUserMessage>
-  options?: Options
-}
-
+    type: 'system';
+    subtype: 'init';
+    apiKeySource: ApiKeySource;
+    cwd: string;
+    session_id: string;
+    tools: string[];
+    mcp_servers: {
+        name: string;
+        status: string;
+    }[];
+    model: string;
+    permissionMode: PermissionMode;
+    slash_commands: string[];
+    output_style: string;
+};
+export type SDKMessage = SDKAssistantMessage | SDKUserMessage | SDKResultMessage | SDKSystemMessage;
 export interface Query extends AsyncGenerator<SDKMessage, void> {
-  /**
-   * Interrupt the query.
-   * Only supported when streaming input is used.
-   */
-  interrupt(): Promise<void>
+    /**
+     * Interrupt the query.
+     * 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
  *
@@ -181,6 +224,9 @@ export interface Query extends AsyncGenerator<SDKMessage, void> {
  * }
  * ```
  */
-export function query({ prompt, options }: Props): Query
-
-export class AbortError extends Error {}
+export declare function query({ prompt, options, }: {
+    prompt: string | AsyncIterable<SDKUserMessage>;
+    options?: Options;
+}): Query;
+export declare class AbortError extends Error {
+}

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.83
+// Version: 1.0.85
 
 // Want to see the unminified source? We're hiring!
 // https://job-boards.greenhouse.io/anthropic/jobs/4816199008
@@ -97,31 +97,37 @@ function createAbortController(maxListeners = DEFAULT_MAX_LISTENERS) {
   return controller;
 }
 
+// src/entrypoints/sdkTypes.ts
+class AbortError extends Error {
+}
+
 // src/entrypoints/sdk.ts
 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
+    strictMcpConfig
   } = {}
 }) {
   if (!env) {
@@ -187,6 +193,9 @@ function query({
   } else {
     args.push("--input-format", "stream-json");
   }
+  for (const dir of additionalDirectories) {
+    args.push("--add-dir", dir);
+  }
   if (!existsSync(pathToClaudeCodeExecutable)) {
     throw new ReferenceError(`Claude Code executable not found at ${pathToClaudeCodeExecutable}. Is options.pathToClaudeCodeExecutable set?`);
   }
@@ -234,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"));
@@ -254,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) {
@@ -363,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);
   }
@@ -375,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;
@@ -389,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 = {
@@ -414,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) {
@@ -432,11 +487,7 @@ function logDebug(message) {
 function isRunningWithBun() {
   return process.versions.bun !== undefined || process.env.BUN_INSTALL !== undefined;
 }
-
-class AbortError extends Error {
-}
 export {
   query,
-  Query,
-  AbortError
+  Query
 };