Class: ClaudeSDK::ClaudeCodeOptions

Inherits:
Object
  • Object
show all
Defined in:
lib/claude_sdk/types.rb

Overview

Query options for Claude SDK

Instance Attribute Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(allowed_tools: [], max_thinking_tokens: 8000, system_prompt: nil, append_system_prompt: nil, mcp_tools: [], mcp_servers: {}, permission_mode: nil, continue_conversation: false, resume: nil, max_turns: nil, disallowed_tools: [], model: nil, permission_prompt_tool_name: nil, cwd: nil, session_id: nil, settings: nil) ⇒ ClaudeCodeOptions

Initialize with default values

Parameters:

  • allowed_tools (Array<String>) (defaults to: []) —

    allowed tools (default: [])

  • max_thinking_tokens (Integer) (defaults to: 8000) —

    max thinking tokens (default: 8000)

  • system_prompt (String, nil) (defaults to: nil) —

    system prompt

  • append_system_prompt (String, nil) (defaults to: nil) —

    append to system prompt

  • mcp_tools (Array<String>) (defaults to: []) —

    MCP tools (default: [])

  • mcp_servers (Hash) (defaults to: {}) —

    MCP servers (default: {})

  • permission_mode (Symbol, nil) (defaults to: nil) —

    permission mode

  • continue_conversation (Boolean) (defaults to: false) —

    continue conversation (default: false)

  • resume (String, nil) (defaults to: nil) —

    resume session ID

  • max_turns (Integer, nil) (defaults to: nil) —

    max turns

  • disallowed_tools (Array<String>) (defaults to: []) —

    disallowed tools (default: [])

  • model (String, nil) (defaults to: nil) —

    model name

  • permission_prompt_tool_name (String, nil) (defaults to: nil) —

    permission tool

  • cwd (String, Pathname, nil) (defaults to: nil) —

    working directory

  • session_id (String, nil) (defaults to: nil) —

    session ID (must be a valid UUID)

  • settings (String, Pathname, nil) (defaults to: nil) —

    path to settings JSON file



362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
 
# File 'lib/claude_sdk/types.rb', line 362

def initialize(allowed_tools: [],
  max_thinking_tokens: 8000,
  system_prompt: nil,
  append_system_prompt: nil,
  mcp_tools: [],
  mcp_servers: {},
  permission_mode: nil,
  continue_conversation: false,
  resume: nil,
  max_turns: nil,
  disallowed_tools: [],
  model: nil,
  permission_prompt_tool_name: nil,
  cwd: nil,
  session_id: nil,
  settings: nil)
  @allowed_tools = allowed_tools
  @max_thinking_tokens = max_thinking_tokens
  @system_prompt = system_prompt
  @append_system_prompt = append_system_prompt
  @mcp_tools = mcp_tools
  @mcp_servers = mcp_servers
  @permission_mode = permission_mode
  @continue_conversation = continue_conversation
  @resume = resume
  @max_turns = max_turns
  @disallowed_tools = disallowed_tools
  @model = model
  @permission_prompt_tool_name = permission_prompt_tool_name
  @cwd = cwd
  @session_id = session_id
  @settings = settings

  validate_permission_mode! if permission_mode
end

Instance Attribute Details

#allowed_tools ⇒ Object

list of allowed tools



326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
 
# File 'lib/claude_sdk/types.rb', line 326

class ClaudeCodeOptions
  attr_accessor :allowed_tools,
    :max_thinking_tokens,
    :system_prompt,
    :append_system_prompt,
    :mcp_tools,
    :mcp_servers,
    :permission_mode,
    :continue_conversation,
    :resume,
    :max_turns,
    :disallowed_tools,
    :model,
    :permission_prompt_tool_name,
    :cwd,
    :session_id,
    :settings

  # Initialize with default values
  #
  # @param allowed_tools [Array<String>] allowed tools (default: [])
  # @param max_thinking_tokens [Integer] max thinking tokens (default: 8000)
  # @param system_prompt [String, nil] system prompt
  # @param append_system_prompt [String, nil] append to system prompt
  # @param mcp_tools [Array<String>] MCP tools (default: [])
  # @param mcp_servers [Hash] MCP servers (default: {})
  # @param permission_mode [Symbol, nil] permission mode
  # @param continue_conversation [Boolean] continue conversation (default: false)
  # @param resume [String, nil] resume session ID
  # @param max_turns [Integer, nil] max turns
  # @param disallowed_tools [Array<String>] disallowed tools (default: [])
  # @param model [String, nil] model name
  # @param permission_prompt_tool_name [String, nil] permission tool
  # @param cwd [String, Pathname, nil] working directory
  # @param session_id [String, nil] session ID (must be a valid UUID)
  # @param settings [String, Pathname, nil] path to settings JSON file
  def initialize(allowed_tools: [],
    max_thinking_tokens: 8000,
    system_prompt: nil,
    append_system_prompt: nil,
    mcp_tools: [],
    mcp_servers: {},
    permission_mode: nil,
    continue_conversation: false,
    resume: nil,
    max_turns: nil,
    disallowed_tools: [],
    model: nil,
    permission_prompt_tool_name: nil,
    cwd: nil,
    session_id: nil,
    settings: nil)
    @allowed_tools = allowed_tools
    @max_thinking_tokens = max_thinking_tokens
    @system_prompt = system_prompt
    @append_system_prompt = append_system_prompt
    @mcp_tools = mcp_tools
    @mcp_servers = mcp_servers
    @permission_mode = permission_mode
    @continue_conversation = continue_conversation
    @resume = resume
    @max_turns = max_turns
    @disallowed_tools = disallowed_tools
    @model = model
    @permission_prompt_tool_name = permission_prompt_tool_name
    @cwd = cwd
    @session_id = session_id
    @settings = settings

    validate_permission_mode! if permission_mode
  end

  # Convert to hash for JSON serialization
  #
  # @return [Hash]
  def to_h
    hash = {}
    hash[:allowed_tools] = allowed_tools unless allowed_tools.empty?
    hash[:max_thinking_tokens] = max_thinking_tokens if max_thinking_tokens != 8000
    hash[:system_prompt] = system_prompt if system_prompt
    hash[:append_system_prompt] = append_system_prompt if append_system_prompt
    hash[:mcp_tools] = mcp_tools unless mcp_tools.empty?
    hash[:mcp_servers] = serialize_mcp_servers unless mcp_servers.empty?
    hash[:permission_mode] = permission_mode.to_s if permission_mode
    hash[:continue_conversation] = continue_conversation if continue_conversation
    hash[:resume] = resume if resume
    hash[:max_turns] = max_turns if max_turns
    hash[:disallowed_tools] = disallowed_tools unless disallowed_tools.empty?
    hash[:model] = model if model
    hash[:permission_prompt_tool_name] = permission_prompt_tool_name if permission_prompt_tool_name
    hash[:cwd] = cwd.to_s if cwd
    hash[:session_id] = session_id if session_id
    hash[:settings] = settings.to_s if settings
    hash
  end

  private

  # Validate permission mode
  def validate_permission_mode!
    return if PermissionMode.valid?(@permission_mode)

    raise ArgumentError, "Invalid permission mode: #{@permission_mode}"
  end

  # Serialize MCP servers to hashes
  def serialize_mcp_servers
    mcp_servers.transform_values do |server|
      server.respond_to?(:to_h) ? server.to_h : server
    end
  end
end

#append_system_prompt ⇒ Object

additional system prompt



326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
 
# File 'lib/claude_sdk/types.rb', line 326

class ClaudeCodeOptions
  attr_accessor :allowed_tools,
    :max_thinking_tokens,
    :system_prompt,
    :append_system_prompt,
    :mcp_tools,
    :mcp_servers,
    :permission_mode,
    :continue_conversation,
    :resume,
    :max_turns,
    :disallowed_tools,
    :model,
    :permission_prompt_tool_name,
    :cwd,
    :session_id,
    :settings

  # Initialize with default values
  #
  # @param allowed_tools [Array<String>] allowed tools (default: [])
  # @param max_thinking_tokens [Integer] max thinking tokens (default: 8000)
  # @param system_prompt [String, nil] system prompt
  # @param append_system_prompt [String, nil] append to system prompt
  # @param mcp_tools [Array<String>] MCP tools (default: [])
  # @param mcp_servers [Hash] MCP servers (default: {})
  # @param permission_mode [Symbol, nil] permission mode
  # @param continue_conversation [Boolean] continue conversation (default: false)
  # @param resume [String, nil] resume session ID
  # @param max_turns [Integer, nil] max turns
  # @param disallowed_tools [Array<String>] disallowed tools (default: [])
  # @param model [String, nil] model name
  # @param permission_prompt_tool_name [String, nil] permission tool
  # @param cwd [String, Pathname, nil] working directory
  # @param session_id [String, nil] session ID (must be a valid UUID)
  # @param settings [String, Pathname, nil] path to settings JSON file
  def initialize(allowed_tools: [],
    max_thinking_tokens: 8000,
    system_prompt: nil,
    append_system_prompt: nil,
    mcp_tools: [],
    mcp_servers: {},
    permission_mode: nil,
    continue_conversation: false,
    resume: nil,
    max_turns: nil,
    disallowed_tools: [],
    model: nil,
    permission_prompt_tool_name: nil,
    cwd: nil,
    session_id: nil,
    settings: nil)
    @allowed_tools = allowed_tools
    @max_thinking_tokens = max_thinking_tokens
    @system_prompt = system_prompt
    @append_system_prompt = append_system_prompt
    @mcp_tools = mcp_tools
    @mcp_servers = mcp_servers
    @permission_mode = permission_mode
    @continue_conversation = continue_conversation
    @resume = resume
    @max_turns = max_turns
    @disallowed_tools = disallowed_tools
    @model = model
    @permission_prompt_tool_name = permission_prompt_tool_name
    @cwd = cwd
    @session_id = session_id
    @settings = settings

    validate_permission_mode! if permission_mode
  end

  # Convert to hash for JSON serialization
  #
  # @return [Hash]
  def to_h
    hash = {}
    hash[:allowed_tools] = allowed_tools unless allowed_tools.empty?
    hash[:max_thinking_tokens] = max_thinking_tokens if max_thinking_tokens != 8000
    hash[:system_prompt] = system_prompt if system_prompt
    hash[:append_system_prompt] = append_system_prompt if append_system_prompt
    hash[:mcp_tools] = mcp_tools unless mcp_tools.empty?
    hash[:mcp_servers] = serialize_mcp_servers unless mcp_servers.empty?
    hash[:permission_mode] = permission_mode.to_s if permission_mode
    hash[:continue_conversation] = continue_conversation if continue_conversation
    hash[:resume] = resume if resume
    hash[:max_turns] = max_turns if max_turns
    hash[:disallowed_tools] = disallowed_tools unless disallowed_tools.empty?
    hash[:model] = model if model
    hash[:permission_prompt_tool_name] = permission_prompt_tool_name if permission_prompt_tool_name
    hash[:cwd] = cwd.to_s if cwd
    hash[:session_id] = session_id if session_id
    hash[:settings] = settings.to_s if settings
    hash
  end

  private

  # Validate permission mode
  def validate_permission_mode!
    return if PermissionMode.valid?(@permission_mode)

    raise ArgumentError, "Invalid permission mode: #{@permission_mode}"
  end

  # Serialize MCP servers to hashes
  def serialize_mcp_servers
    mcp_servers.transform_values do |server|
      server.respond_to?(:to_h) ? server.to_h : server
    end
  end
end

#continue_conversation ⇒ Object

Returns the value of attribute continue_conversation.



327
328
329
 
# File 'lib/claude_sdk/types.rb', line 327

def continue_conversation
  @continue_conversation
end

#cwd ⇒ Object

working directory



326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
 
# File 'lib/claude_sdk/types.rb', line 326

class ClaudeCodeOptions
  attr_accessor :allowed_tools,
    :max_thinking_tokens,
    :system_prompt,
    :append_system_prompt,
    :mcp_tools,
    :mcp_servers,
    :permission_mode,
    :continue_conversation,
    :resume,
    :max_turns,
    :disallowed_tools,
    :model,
    :permission_prompt_tool_name,
    :cwd,
    :session_id,
    :settings

  # Initialize with default values
  #
  # @param allowed_tools [Array<String>] allowed tools (default: [])
  # @param max_thinking_tokens [Integer] max thinking tokens (default: 8000)
  # @param system_prompt [String, nil] system prompt
  # @param append_system_prompt [String, nil] append to system prompt
  # @param mcp_tools [Array<String>] MCP tools (default: [])
  # @param mcp_servers [Hash] MCP servers (default: {})
  # @param permission_mode [Symbol, nil] permission mode
  # @param continue_conversation [Boolean] continue conversation (default: false)
  # @param resume [String, nil] resume session ID
  # @param max_turns [Integer, nil] max turns
  # @param disallowed_tools [Array<String>] disallowed tools (default: [])
  # @param model [String, nil] model name
  # @param permission_prompt_tool_name [String, nil] permission tool
  # @param cwd [String, Pathname, nil] working directory
  # @param session_id [String, nil] session ID (must be a valid UUID)
  # @param settings [String, Pathname, nil] path to settings JSON file
  def initialize(allowed_tools: [],
    max_thinking_tokens: 8000,
    system_prompt: nil,
    append_system_prompt: nil,
    mcp_tools: [],
    mcp_servers: {},
    permission_mode: nil,
    continue_conversation: false,
    resume: nil,
    max_turns: nil,
    disallowed_tools: [],
    model: nil,
    permission_prompt_tool_name: nil,
    cwd: nil,
    session_id: nil,
    settings: nil)
    @allowed_tools = allowed_tools
    @max_thinking_tokens = max_thinking_tokens
    @system_prompt = system_prompt
    @append_system_prompt = append_system_prompt
    @mcp_tools = mcp_tools
    @mcp_servers = mcp_servers
    @permission_mode = permission_mode
    @continue_conversation = continue_conversation
    @resume = resume
    @max_turns = max_turns
    @disallowed_tools = disallowed_tools
    @model = model
    @permission_prompt_tool_name = permission_prompt_tool_name
    @cwd = cwd
    @session_id = session_id
    @settings = settings

    validate_permission_mode! if permission_mode
  end

  # Convert to hash for JSON serialization
  #
  # @return [Hash]
  def to_h
    hash = {}
    hash[:allowed_tools] = allowed_tools unless allowed_tools.empty?
    hash[:max_thinking_tokens] = max_thinking_tokens if max_thinking_tokens != 8000
    hash[:system_prompt] = system_prompt if system_prompt
    hash[:append_system_prompt] = append_system_prompt if append_system_prompt
    hash[:mcp_tools] = mcp_tools unless mcp_tools.empty?
    hash[:mcp_servers] = serialize_mcp_servers unless mcp_servers.empty?
    hash[:permission_mode] = permission_mode.to_s if permission_mode
    hash[:continue_conversation] = continue_conversation if continue_conversation
    hash[:resume] = resume if resume
    hash[:max_turns] = max_turns if max_turns
    hash[:disallowed_tools] = disallowed_tools unless disallowed_tools.empty?
    hash[:model] = model if model
    hash[:permission_prompt_tool_name] = permission_prompt_tool_name if permission_prompt_tool_name
    hash[:cwd] = cwd.to_s if cwd
    hash[:session_id] = session_id if session_id
    hash[:settings] = settings.to_s if settings
    hash
  end

  private

  # Validate permission mode
  def validate_permission_mode!
    return if PermissionMode.valid?(@permission_mode)

    raise ArgumentError, "Invalid permission mode: #{@permission_mode}"
  end

  # Serialize MCP servers to hashes
  def serialize_mcp_servers
    mcp_servers.transform_values do |server|
      server.respond_to?(:to_h) ? server.to_h : server
    end
  end
end

#disallowed_tools ⇒ Object

list of disallowed tools



326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
 
# File 'lib/claude_sdk/types.rb', line 326

class ClaudeCodeOptions
  attr_accessor :allowed_tools,
    :max_thinking_tokens,
    :system_prompt,
    :append_system_prompt,
    :mcp_tools,
    :mcp_servers,
    :permission_mode,
    :continue_conversation,
    :resume,
    :max_turns,
    :disallowed_tools,
    :model,
    :permission_prompt_tool_name,
    :cwd,
    :session_id,
    :settings

  # Initialize with default values
  #
  # @param allowed_tools [Array<String>] allowed tools (default: [])
  # @param max_thinking_tokens [Integer] max thinking tokens (default: 8000)
  # @param system_prompt [String, nil] system prompt
  # @param append_system_prompt [String, nil] append to system prompt
  # @param mcp_tools [Array<String>] MCP tools (default: [])
  # @param mcp_servers [Hash] MCP servers (default: {})
  # @param permission_mode [Symbol, nil] permission mode
  # @param continue_conversation [Boolean] continue conversation (default: false)
  # @param resume [String, nil] resume session ID
  # @param max_turns [Integer, nil] max turns
  # @param disallowed_tools [Array<String>] disallowed tools (default: [])
  # @param model [String, nil] model name
  # @param permission_prompt_tool_name [String, nil] permission tool
  # @param cwd [String, Pathname, nil] working directory
  # @param session_id [String, nil] session ID (must be a valid UUID)
  # @param settings [String, Pathname, nil] path to settings JSON file
  def initialize(allowed_tools: [],
    max_thinking_tokens: 8000,
    system_prompt: nil,
    append_system_prompt: nil,
    mcp_tools: [],
    mcp_servers: {},
    permission_mode: nil,
    continue_conversation: false,
    resume: nil,
    max_turns: nil,
    disallowed_tools: [],
    model: nil,
    permission_prompt_tool_name: nil,
    cwd: nil,
    session_id: nil,
    settings: nil)
    @allowed_tools = allowed_tools
    @max_thinking_tokens = max_thinking_tokens
    @system_prompt = system_prompt
    @append_system_prompt = append_system_prompt
    @mcp_tools = mcp_tools
    @mcp_servers = mcp_servers
    @permission_mode = permission_mode
    @continue_conversation = continue_conversation
    @resume = resume
    @max_turns = max_turns
    @disallowed_tools = disallowed_tools
    @model = model
    @permission_prompt_tool_name = permission_prompt_tool_name
    @cwd = cwd
    @session_id = session_id
    @settings = settings

    validate_permission_mode! if permission_mode
  end

  # Convert to hash for JSON serialization
  #
  # @return [Hash]
  def to_h
    hash = {}
    hash[:allowed_tools] = allowed_tools unless allowed_tools.empty?
    hash[:max_thinking_tokens] = max_thinking_tokens if max_thinking_tokens != 8000
    hash[:system_prompt] = system_prompt if system_prompt
    hash[:append_system_prompt] = append_system_prompt if append_system_prompt
    hash[:mcp_tools] = mcp_tools unless mcp_tools.empty?
    hash[:mcp_servers] = serialize_mcp_servers unless mcp_servers.empty?
    hash[:permission_mode] = permission_mode.to_s if permission_mode
    hash[:continue_conversation] = continue_conversation if continue_conversation
    hash[:resume] = resume if resume
    hash[:max_turns] = max_turns if max_turns
    hash[:disallowed_tools] = disallowed_tools unless disallowed_tools.empty?
    hash[:model] = model if model
    hash[:permission_prompt_tool_name] = permission_prompt_tool_name if permission_prompt_tool_name
    hash[:cwd] = cwd.to_s if cwd
    hash[:session_id] = session_id if session_id
    hash[:settings] = settings.to_s if settings
    hash
  end

  private

  # Validate permission mode
  def validate_permission_mode!
    return if PermissionMode.valid?(@permission_mode)

    raise ArgumentError, "Invalid permission mode: #{@permission_mode}"
  end

  # Serialize MCP servers to hashes
  def serialize_mcp_servers
    mcp_servers.transform_values do |server|
      server.respond_to?(:to_h) ? server.to_h : server
    end
  end
end

#max_thinking_tokens ⇒ Object

maximum thinking tokens



326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
 
# File 'lib/claude_sdk/types.rb', line 326

class ClaudeCodeOptions
  attr_accessor :allowed_tools,
    :max_thinking_tokens,
    :system_prompt,
    :append_system_prompt,
    :mcp_tools,
    :mcp_servers,
    :permission_mode,
    :continue_conversation,
    :resume,
    :max_turns,
    :disallowed_tools,
    :model,
    :permission_prompt_tool_name,
    :cwd,
    :session_id,
    :settings

  # Initialize with default values
  #
  # @param allowed_tools [Array<String>] allowed tools (default: [])
  # @param max_thinking_tokens [Integer] max thinking tokens (default: 8000)
  # @param system_prompt [String, nil] system prompt
  # @param append_system_prompt [String, nil] append to system prompt
  # @param mcp_tools [Array<String>] MCP tools (default: [])
  # @param mcp_servers [Hash] MCP servers (default: {})
  # @param permission_mode [Symbol, nil] permission mode
  # @param continue_conversation [Boolean] continue conversation (default: false)
  # @param resume [String, nil] resume session ID
  # @param max_turns [Integer, nil] max turns
  # @param disallowed_tools [Array<String>] disallowed tools (default: [])
  # @param model [String, nil] model name
  # @param permission_prompt_tool_name [String, nil] permission tool
  # @param cwd [String, Pathname, nil] working directory
  # @param session_id [String, nil] session ID (must be a valid UUID)
  # @param settings [String, Pathname, nil] path to settings JSON file
  def initialize(allowed_tools: [],
    max_thinking_tokens: 8000,
    system_prompt: nil,
    append_system_prompt: nil,
    mcp_tools: [],
    mcp_servers: {},
    permission_mode: nil,
    continue_conversation: false,
    resume: nil,
    max_turns: nil,
    disallowed_tools: [],
    model: nil,
    permission_prompt_tool_name: nil,
    cwd: nil,
    session_id: nil,
    settings: nil)
    @allowed_tools = allowed_tools
    @max_thinking_tokens = max_thinking_tokens
    @system_prompt = system_prompt
    @append_system_prompt = append_system_prompt
    @mcp_tools = mcp_tools
    @mcp_servers = mcp_servers
    @permission_mode = permission_mode
    @continue_conversation = continue_conversation
    @resume = resume
    @max_turns = max_turns
    @disallowed_tools = disallowed_tools
    @model = model
    @permission_prompt_tool_name = permission_prompt_tool_name
    @cwd = cwd
    @session_id = session_id
    @settings = settings

    validate_permission_mode! if permission_mode
  end

  # Convert to hash for JSON serialization
  #
  # @return [Hash]
  def to_h
    hash = {}
    hash[:allowed_tools] = allowed_tools unless allowed_tools.empty?
    hash[:max_thinking_tokens] = max_thinking_tokens if max_thinking_tokens != 8000
    hash[:system_prompt] = system_prompt if system_prompt
    hash[:append_system_prompt] = append_system_prompt if append_system_prompt
    hash[:mcp_tools] = mcp_tools unless mcp_tools.empty?
    hash[:mcp_servers] = serialize_mcp_servers unless mcp_servers.empty?
    hash[:permission_mode] = permission_mode.to_s if permission_mode
    hash[:continue_conversation] = continue_conversation if continue_conversation
    hash[:resume] = resume if resume
    hash[:max_turns] = max_turns if max_turns
    hash[:disallowed_tools] = disallowed_tools unless disallowed_tools.empty?
    hash[:model] = model if model
    hash[:permission_prompt_tool_name] = permission_prompt_tool_name if permission_prompt_tool_name
    hash[:cwd] = cwd.to_s if cwd
    hash[:session_id] = session_id if session_id
    hash[:settings] = settings.to_s if settings
    hash
  end

  private

  # Validate permission mode
  def validate_permission_mode!
    return if PermissionMode.valid?(@permission_mode)

    raise ArgumentError, "Invalid permission mode: #{@permission_mode}"
  end

  # Serialize MCP servers to hashes
  def serialize_mcp_servers
    mcp_servers.transform_values do |server|
      server.respond_to?(:to_h) ? server.to_h : server
    end
  end
end

#max_turns ⇒ Object

maximum conversation turns



326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
 
# File 'lib/claude_sdk/types.rb', line 326

class ClaudeCodeOptions
  attr_accessor :allowed_tools,
    :max_thinking_tokens,
    :system_prompt,
    :append_system_prompt,
    :mcp_tools,
    :mcp_servers,
    :permission_mode,
    :continue_conversation,
    :resume,
    :max_turns,
    :disallowed_tools,
    :model,
    :permission_prompt_tool_name,
    :cwd,
    :session_id,
    :settings

  # Initialize with default values
  #
  # @param allowed_tools [Array<String>] allowed tools (default: [])
  # @param max_thinking_tokens [Integer] max thinking tokens (default: 8000)
  # @param system_prompt [String, nil] system prompt
  # @param append_system_prompt [String, nil] append to system prompt
  # @param mcp_tools [Array<String>] MCP tools (default: [])
  # @param mcp_servers [Hash] MCP servers (default: {})
  # @param permission_mode [Symbol, nil] permission mode
  # @param continue_conversation [Boolean] continue conversation (default: false)
  # @param resume [String, nil] resume session ID
  # @param max_turns [Integer, nil] max turns
  # @param disallowed_tools [Array<String>] disallowed tools (default: [])
  # @param model [String, nil] model name
  # @param permission_prompt_tool_name [String, nil] permission tool
  # @param cwd [String, Pathname, nil] working directory
  # @param session_id [String, nil] session ID (must be a valid UUID)
  # @param settings [String, Pathname, nil] path to settings JSON file
  def initialize(allowed_tools: [],
    max_thinking_tokens: 8000,
    system_prompt: nil,
    append_system_prompt: nil,
    mcp_tools: [],
    mcp_servers: {},
    permission_mode: nil,
    continue_conversation: false,
    resume: nil,
    max_turns: nil,
    disallowed_tools: [],
    model: nil,
    permission_prompt_tool_name: nil,
    cwd: nil,
    session_id: nil,
    settings: nil)
    @allowed_tools = allowed_tools
    @max_thinking_tokens = max_thinking_tokens
    @system_prompt = system_prompt
    @append_system_prompt = append_system_prompt
    @mcp_tools = mcp_tools
    @mcp_servers = mcp_servers
    @permission_mode = permission_mode
    @continue_conversation = continue_conversation
    @resume = resume
    @max_turns = max_turns
    @disallowed_tools = disallowed_tools
    @model = model
    @permission_prompt_tool_name = permission_prompt_tool_name
    @cwd = cwd
    @session_id = session_id
    @settings = settings

    validate_permission_mode! if permission_mode
  end

  # Convert to hash for JSON serialization
  #
  # @return [Hash]
  def to_h
    hash = {}
    hash[:allowed_tools] = allowed_tools unless allowed_tools.empty?
    hash[:max_thinking_tokens] = max_thinking_tokens if max_thinking_tokens != 8000
    hash[:system_prompt] = system_prompt if system_prompt
    hash[:append_system_prompt] = append_system_prompt if append_system_prompt
    hash[:mcp_tools] = mcp_tools unless mcp_tools.empty?
    hash[:mcp_servers] = serialize_mcp_servers unless mcp_servers.empty?
    hash[:permission_mode] = permission_mode.to_s if permission_mode
    hash[:continue_conversation] = continue_conversation if continue_conversation
    hash[:resume] = resume if resume
    hash[:max_turns] = max_turns if max_turns
    hash[:disallowed_tools] = disallowed_tools unless disallowed_tools.empty?
    hash[:model] = model if model
    hash[:permission_prompt_tool_name] = permission_prompt_tool_name if permission_prompt_tool_name
    hash[:cwd] = cwd.to_s if cwd
    hash[:session_id] = session_id if session_id
    hash[:settings] = settings.to_s if settings
    hash
  end

  private

  # Validate permission mode
  def validate_permission_mode!
    return if PermissionMode.valid?(@permission_mode)

    raise ArgumentError, "Invalid permission mode: #{@permission_mode}"
  end

  # Serialize MCP servers to hashes
  def serialize_mcp_servers
    mcp_servers.transform_values do |server|
      server.respond_to?(:to_h) ? server.to_h : server
    end
  end
end

#mcp_servers ⇒ Object

MCP server configurations



326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
 
# File 'lib/claude_sdk/types.rb', line 326

class ClaudeCodeOptions
  attr_accessor :allowed_tools,
    :max_thinking_tokens,
    :system_prompt,
    :append_system_prompt,
    :mcp_tools,
    :mcp_servers,
    :permission_mode,
    :continue_conversation,
    :resume,
    :max_turns,
    :disallowed_tools,
    :model,
    :permission_prompt_tool_name,
    :cwd,
    :session_id,
    :settings

  # Initialize with default values
  #
  # @param allowed_tools [Array<String>] allowed tools (default: [])
  # @param max_thinking_tokens [Integer] max thinking tokens (default: 8000)
  # @param system_prompt [String, nil] system prompt
  # @param append_system_prompt [String, nil] append to system prompt
  # @param mcp_tools [Array<String>] MCP tools (default: [])
  # @param mcp_servers [Hash] MCP servers (default: {})
  # @param permission_mode [Symbol, nil] permission mode
  # @param continue_conversation [Boolean] continue conversation (default: false)
  # @param resume [String, nil] resume session ID
  # @param max_turns [Integer, nil] max turns
  # @param disallowed_tools [Array<String>] disallowed tools (default: [])
  # @param model [String, nil] model name
  # @param permission_prompt_tool_name [String, nil] permission tool
  # @param cwd [String, Pathname, nil] working directory
  # @param session_id [String, nil] session ID (must be a valid UUID)
  # @param settings [String, Pathname, nil] path to settings JSON file
  def initialize(allowed_tools: [],
    max_thinking_tokens: 8000,
    system_prompt: nil,
    append_system_prompt: nil,
    mcp_tools: [],
    mcp_servers: {},
    permission_mode: nil,
    continue_conversation: false,
    resume: nil,
    max_turns: nil,
    disallowed_tools: [],
    model: nil,
    permission_prompt_tool_name: nil,
    cwd: nil,
    session_id: nil,
    settings: nil)
    @allowed_tools = allowed_tools
    @max_thinking_tokens = max_thinking_tokens
    @system_prompt = system_prompt
    @append_system_prompt = append_system_prompt
    @mcp_tools = mcp_tools
    @mcp_servers = mcp_servers
    @permission_mode = permission_mode
    @continue_conversation = continue_conversation
    @resume = resume
    @max_turns = max_turns
    @disallowed_tools = disallowed_tools
    @model = model
    @permission_prompt_tool_name = permission_prompt_tool_name
    @cwd = cwd
    @session_id = session_id
    @settings = settings

    validate_permission_mode! if permission_mode
  end

  # Convert to hash for JSON serialization
  #
  # @return [Hash]
  def to_h
    hash = {}
    hash[:allowed_tools] = allowed_tools unless allowed_tools.empty?
    hash[:max_thinking_tokens] = max_thinking_tokens if max_thinking_tokens != 8000
    hash[:system_prompt] = system_prompt if system_prompt
    hash[:append_system_prompt] = append_system_prompt if append_system_prompt
    hash[:mcp_tools] = mcp_tools unless mcp_tools.empty?
    hash[:mcp_servers] = serialize_mcp_servers unless mcp_servers.empty?
    hash[:permission_mode] = permission_mode.to_s if permission_mode
    hash[:continue_conversation] = continue_conversation if continue_conversation
    hash[:resume] = resume if resume
    hash[:max_turns] = max_turns if max_turns
    hash[:disallowed_tools] = disallowed_tools unless disallowed_tools.empty?
    hash[:model] = model if model
    hash[:permission_prompt_tool_name] = permission_prompt_tool_name if permission_prompt_tool_name
    hash[:cwd] = cwd.to_s if cwd
    hash[:session_id] = session_id if session_id
    hash[:settings] = settings.to_s if settings
    hash
  end

  private

  # Validate permission mode
  def validate_permission_mode!
    return if PermissionMode.valid?(@permission_mode)

    raise ArgumentError, "Invalid permission mode: #{@permission_mode}"
  end

  # Serialize MCP servers to hashes
  def serialize_mcp_servers
    mcp_servers.transform_values do |server|
      server.respond_to?(:to_h) ? server.to_h : server
    end
  end
end

#mcp_tools ⇒ Object

MCP tools to enable



326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
 
# File 'lib/claude_sdk/types.rb', line 326

class ClaudeCodeOptions
  attr_accessor :allowed_tools,
    :max_thinking_tokens,
    :system_prompt,
    :append_system_prompt,
    :mcp_tools,
    :mcp_servers,
    :permission_mode,
    :continue_conversation,
    :resume,
    :max_turns,
    :disallowed_tools,
    :model,
    :permission_prompt_tool_name,
    :cwd,
    :session_id,
    :settings

  # Initialize with default values
  #
  # @param allowed_tools [Array<String>] allowed tools (default: [])
  # @param max_thinking_tokens [Integer] max thinking tokens (default: 8000)
  # @param system_prompt [String, nil] system prompt
  # @param append_system_prompt [String, nil] append to system prompt
  # @param mcp_tools [Array<String>] MCP tools (default: [])
  # @param mcp_servers [Hash] MCP servers (default: {})
  # @param permission_mode [Symbol, nil] permission mode
  # @param continue_conversation [Boolean] continue conversation (default: false)
  # @param resume [String, nil] resume session ID
  # @param max_turns [Integer, nil] max turns
  # @param disallowed_tools [Array<String>] disallowed tools (default: [])
  # @param model [String, nil] model name
  # @param permission_prompt_tool_name [String, nil] permission tool
  # @param cwd [String, Pathname, nil] working directory
  # @param session_id [String, nil] session ID (must be a valid UUID)
  # @param settings [String, Pathname, nil] path to settings JSON file
  def initialize(allowed_tools: [],
    max_thinking_tokens: 8000,
    system_prompt: nil,
    append_system_prompt: nil,
    mcp_tools: [],
    mcp_servers: {},
    permission_mode: nil,
    continue_conversation: false,
    resume: nil,
    max_turns: nil,
    disallowed_tools: [],
    model: nil,
    permission_prompt_tool_name: nil,
    cwd: nil,
    session_id: nil,
    settings: nil)
    @allowed_tools = allowed_tools
    @max_thinking_tokens = max_thinking_tokens
    @system_prompt = system_prompt
    @append_system_prompt = append_system_prompt
    @mcp_tools = mcp_tools
    @mcp_servers = mcp_servers
    @permission_mode = permission_mode
    @continue_conversation = continue_conversation
    @resume = resume
    @max_turns = max_turns
    @disallowed_tools = disallowed_tools
    @model = model
    @permission_prompt_tool_name = permission_prompt_tool_name
    @cwd = cwd
    @session_id = session_id
    @settings = settings

    validate_permission_mode! if permission_mode
  end

  # Convert to hash for JSON serialization
  #
  # @return [Hash]
  def to_h
    hash = {}
    hash[:allowed_tools] = allowed_tools unless allowed_tools.empty?
    hash[:max_thinking_tokens] = max_thinking_tokens if max_thinking_tokens != 8000
    hash[:system_prompt] = system_prompt if system_prompt
    hash[:append_system_prompt] = append_system_prompt if append_system_prompt
    hash[:mcp_tools] = mcp_tools unless mcp_tools.empty?
    hash[:mcp_servers] = serialize_mcp_servers unless mcp_servers.empty?
    hash[:permission_mode] = permission_mode.to_s if permission_mode
    hash[:continue_conversation] = continue_conversation if continue_conversation
    hash[:resume] = resume if resume
    hash[:max_turns] = max_turns if max_turns
    hash[:disallowed_tools] = disallowed_tools unless disallowed_tools.empty?
    hash[:model] = model if model
    hash[:permission_prompt_tool_name] = permission_prompt_tool_name if permission_prompt_tool_name
    hash[:cwd] = cwd.to_s if cwd
    hash[:session_id] = session_id if session_id
    hash[:settings] = settings.to_s if settings
    hash
  end

  private

  # Validate permission mode
  def validate_permission_mode!
    return if PermissionMode.valid?(@permission_mode)

    raise ArgumentError, "Invalid permission mode: #{@permission_mode}"
  end

  # Serialize MCP servers to hashes
  def serialize_mcp_servers
    mcp_servers.transform_values do |server|
      server.respond_to?(:to_h) ? server.to_h : server
    end
  end
end

#model ⇒ Object

model to use



326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
 
# File 'lib/claude_sdk/types.rb', line 326

class ClaudeCodeOptions
  attr_accessor :allowed_tools,
    :max_thinking_tokens,
    :system_prompt,
    :append_system_prompt,
    :mcp_tools,
    :mcp_servers,
    :permission_mode,
    :continue_conversation,
    :resume,
    :max_turns,
    :disallowed_tools,
    :model,
    :permission_prompt_tool_name,
    :cwd,
    :session_id,
    :settings

  # Initialize with default values
  #
  # @param allowed_tools [Array<String>] allowed tools (default: [])
  # @param max_thinking_tokens [Integer] max thinking tokens (default: 8000)
  # @param system_prompt [String, nil] system prompt
  # @param append_system_prompt [String, nil] append to system prompt
  # @param mcp_tools [Array<String>] MCP tools (default: [])
  # @param mcp_servers [Hash] MCP servers (default: {})
  # @param permission_mode [Symbol, nil] permission mode
  # @param continue_conversation [Boolean] continue conversation (default: false)
  # @param resume [String, nil] resume session ID
  # @param max_turns [Integer, nil] max turns
  # @param disallowed_tools [Array<String>] disallowed tools (default: [])
  # @param model [String, nil] model name
  # @param permission_prompt_tool_name [String, nil] permission tool
  # @param cwd [String, Pathname, nil] working directory
  # @param session_id [String, nil] session ID (must be a valid UUID)
  # @param settings [String, Pathname, nil] path to settings JSON file
  def initialize(allowed_tools: [],
    max_thinking_tokens: 8000,
    system_prompt: nil,
    append_system_prompt: nil,
    mcp_tools: [],
    mcp_servers: {},
    permission_mode: nil,
    continue_conversation: false,
    resume: nil,
    max_turns: nil,
    disallowed_tools: [],
    model: nil,
    permission_prompt_tool_name: nil,
    cwd: nil,
    session_id: nil,
    settings: nil)
    @allowed_tools = allowed_tools
    @max_thinking_tokens = max_thinking_tokens
    @system_prompt = system_prompt
    @append_system_prompt = append_system_prompt
    @mcp_tools = mcp_tools
    @mcp_servers = mcp_servers
    @permission_mode = permission_mode
    @continue_conversation = continue_conversation
    @resume = resume
    @max_turns = max_turns
    @disallowed_tools = disallowed_tools
    @model = model
    @permission_prompt_tool_name = permission_prompt_tool_name
    @cwd = cwd
    @session_id = session_id
    @settings = settings

    validate_permission_mode! if permission_mode
  end

  # Convert to hash for JSON serialization
  #
  # @return [Hash]
  def to_h
    hash = {}
    hash[:allowed_tools] = allowed_tools unless allowed_tools.empty?
    hash[:max_thinking_tokens] = max_thinking_tokens if max_thinking_tokens != 8000
    hash[:system_prompt] = system_prompt if system_prompt
    hash[:append_system_prompt] = append_system_prompt if append_system_prompt
    hash[:mcp_tools] = mcp_tools unless mcp_tools.empty?
    hash[:mcp_servers] = serialize_mcp_servers unless mcp_servers.empty?
    hash[:permission_mode] = permission_mode.to_s if permission_mode
    hash[:continue_conversation] = continue_conversation if continue_conversation
    hash[:resume] = resume if resume
    hash[:max_turns] = max_turns if max_turns
    hash[:disallowed_tools] = disallowed_tools unless disallowed_tools.empty?
    hash[:model] = model if model
    hash[:permission_prompt_tool_name] = permission_prompt_tool_name if permission_prompt_tool_name
    hash[:cwd] = cwd.to_s if cwd
    hash[:session_id] = session_id if session_id
    hash[:settings] = settings.to_s if settings
    hash
  end

  private

  # Validate permission mode
  def validate_permission_mode!
    return if PermissionMode.valid?(@permission_mode)

    raise ArgumentError, "Invalid permission mode: #{@permission_mode}"
  end

  # Serialize MCP servers to hashes
  def serialize_mcp_servers
    mcp_servers.transform_values do |server|
      server.respond_to?(:to_h) ? server.to_h : server
    end
  end
end

#permission_mode ⇒ Object

Returns the value of attribute permission_mode.



327
328
329
 
# File 'lib/claude_sdk/types.rb', line 327

def permission_mode
  @permission_mode
end

#permission_prompt_tool_name ⇒ Object

permission prompt tool



326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
 
# File 'lib/claude_sdk/types.rb', line 326

class ClaudeCodeOptions
  attr_accessor :allowed_tools,
    :max_thinking_tokens,
    :system_prompt,
    :append_system_prompt,
    :mcp_tools,
    :mcp_servers,
    :permission_mode,
    :continue_conversation,
    :resume,
    :max_turns,
    :disallowed_tools,
    :model,
    :permission_prompt_tool_name,
    :cwd,
    :session_id,
    :settings

  # Initialize with default values
  #
  # @param allowed_tools [Array<String>] allowed tools (default: [])
  # @param max_thinking_tokens [Integer] max thinking tokens (default: 8000)
  # @param system_prompt [String, nil] system prompt
  # @param append_system_prompt [String, nil] append to system prompt
  # @param mcp_tools [Array<String>] MCP tools (default: [])
  # @param mcp_servers [Hash] MCP servers (default: {})
  # @param permission_mode [Symbol, nil] permission mode
  # @param continue_conversation [Boolean] continue conversation (default: false)
  # @param resume [String, nil] resume session ID
  # @param max_turns [Integer, nil] max turns
  # @param disallowed_tools [Array<String>] disallowed tools (default: [])
  # @param model [String, nil] model name
  # @param permission_prompt_tool_name [String, nil] permission tool
  # @param cwd [String, Pathname, nil] working directory
  # @param session_id [String, nil] session ID (must be a valid UUID)
  # @param settings [String, Pathname, nil] path to settings JSON file
  def initialize(allowed_tools: [],
    max_thinking_tokens: 8000,
    system_prompt: nil,
    append_system_prompt: nil,
    mcp_tools: [],
    mcp_servers: {},
    permission_mode: nil,
    continue_conversation: false,
    resume: nil,
    max_turns: nil,
    disallowed_tools: [],
    model: nil,
    permission_prompt_tool_name: nil,
    cwd: nil,
    session_id: nil,
    settings: nil)
    @allowed_tools = allowed_tools
    @max_thinking_tokens = max_thinking_tokens
    @system_prompt = system_prompt
    @append_system_prompt = append_system_prompt
    @mcp_tools = mcp_tools
    @mcp_servers = mcp_servers
    @permission_mode = permission_mode
    @continue_conversation = continue_conversation
    @resume = resume
    @max_turns = max_turns
    @disallowed_tools = disallowed_tools
    @model = model
    @permission_prompt_tool_name = permission_prompt_tool_name
    @cwd = cwd
    @session_id = session_id
    @settings = settings

    validate_permission_mode! if permission_mode
  end

  # Convert to hash for JSON serialization
  #
  # @return [Hash]
  def to_h
    hash = {}
    hash[:allowed_tools] = allowed_tools unless allowed_tools.empty?
    hash[:max_thinking_tokens] = max_thinking_tokens if max_thinking_tokens != 8000
    hash[:system_prompt] = system_prompt if system_prompt
    hash[:append_system_prompt] = append_system_prompt if append_system_prompt
    hash[:mcp_tools] = mcp_tools unless mcp_tools.empty?
    hash[:mcp_servers] = serialize_mcp_servers unless mcp_servers.empty?
    hash[:permission_mode] = permission_mode.to_s if permission_mode
    hash[:continue_conversation] = continue_conversation if continue_conversation
    hash[:resume] = resume if resume
    hash[:max_turns] = max_turns if max_turns
    hash[:disallowed_tools] = disallowed_tools unless disallowed_tools.empty?
    hash[:model] = model if model
    hash[:permission_prompt_tool_name] = permission_prompt_tool_name if permission_prompt_tool_name
    hash[:cwd] = cwd.to_s if cwd
    hash[:session_id] = session_id if session_id
    hash[:settings] = settings.to_s if settings
    hash
  end

  private

  # Validate permission mode
  def validate_permission_mode!
    return if PermissionMode.valid?(@permission_mode)

    raise ArgumentError, "Invalid permission mode: #{@permission_mode}"
  end

  # Serialize MCP servers to hashes
  def serialize_mcp_servers
    mcp_servers.transform_values do |server|
      server.respond_to?(:to_h) ? server.to_h : server
    end
  end
end

#resume ⇒ Object

resume from session ID



326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
 
# File 'lib/claude_sdk/types.rb', line 326

class ClaudeCodeOptions
  attr_accessor :allowed_tools,
    :max_thinking_tokens,
    :system_prompt,
    :append_system_prompt,
    :mcp_tools,
    :mcp_servers,
    :permission_mode,
    :continue_conversation,
    :resume,
    :max_turns,
    :disallowed_tools,
    :model,
    :permission_prompt_tool_name,
    :cwd,
    :session_id,
    :settings

  # Initialize with default values
  #
  # @param allowed_tools [Array<String>] allowed tools (default: [])
  # @param max_thinking_tokens [Integer] max thinking tokens (default: 8000)
  # @param system_prompt [String, nil] system prompt
  # @param append_system_prompt [String, nil] append to system prompt
  # @param mcp_tools [Array<String>] MCP tools (default: [])
  # @param mcp_servers [Hash] MCP servers (default: {})
  # @param permission_mode [Symbol, nil] permission mode
  # @param continue_conversation [Boolean] continue conversation (default: false)
  # @param resume [String, nil] resume session ID
  # @param max_turns [Integer, nil] max turns
  # @param disallowed_tools [Array<String>] disallowed tools (default: [])
  # @param model [String, nil] model name
  # @param permission_prompt_tool_name [String, nil] permission tool
  # @param cwd [String, Pathname, nil] working directory
  # @param session_id [String, nil] session ID (must be a valid UUID)
  # @param settings [String, Pathname, nil] path to settings JSON file
  def initialize(allowed_tools: [],
    max_thinking_tokens: 8000,
    system_prompt: nil,
    append_system_prompt: nil,
    mcp_tools: [],
    mcp_servers: {},
    permission_mode: nil,
    continue_conversation: false,
    resume: nil,
    max_turns: nil,
    disallowed_tools: [],
    model: nil,
    permission_prompt_tool_name: nil,
    cwd: nil,
    session_id: nil,
    settings: nil)
    @allowed_tools = allowed_tools
    @max_thinking_tokens = max_thinking_tokens
    @system_prompt = system_prompt
    @append_system_prompt = append_system_prompt
    @mcp_tools = mcp_tools
    @mcp_servers = mcp_servers
    @permission_mode = permission_mode
    @continue_conversation = continue_conversation
    @resume = resume
    @max_turns = max_turns
    @disallowed_tools = disallowed_tools
    @model = model
    @permission_prompt_tool_name = permission_prompt_tool_name
    @cwd = cwd
    @session_id = session_id
    @settings = settings

    validate_permission_mode! if permission_mode
  end

  # Convert to hash for JSON serialization
  #
  # @return [Hash]
  def to_h
    hash = {}
    hash[:allowed_tools] = allowed_tools unless allowed_tools.empty?
    hash[:max_thinking_tokens] = max_thinking_tokens if max_thinking_tokens != 8000
    hash[:system_prompt] = system_prompt if system_prompt
    hash[:append_system_prompt] = append_system_prompt if append_system_prompt
    hash[:mcp_tools] = mcp_tools unless mcp_tools.empty?
    hash[:mcp_servers] = serialize_mcp_servers unless mcp_servers.empty?
    hash[:permission_mode] = permission_mode.to_s if permission_mode
    hash[:continue_conversation] = continue_conversation if continue_conversation
    hash[:resume] = resume if resume
    hash[:max_turns] = max_turns if max_turns
    hash[:disallowed_tools] = disallowed_tools unless disallowed_tools.empty?
    hash[:model] = model if model
    hash[:permission_prompt_tool_name] = permission_prompt_tool_name if permission_prompt_tool_name
    hash[:cwd] = cwd.to_s if cwd
    hash[:session_id] = session_id if session_id
    hash[:settings] = settings.to_s if settings
    hash
  end

  private

  # Validate permission mode
  def validate_permission_mode!
    return if PermissionMode.valid?(@permission_mode)

    raise ArgumentError, "Invalid permission mode: #{@permission_mode}"
  end

  # Serialize MCP servers to hashes
  def serialize_mcp_servers
    mcp_servers.transform_values do |server|
      server.respond_to?(:to_h) ? server.to_h : server
    end
  end
end

#session_id ⇒ Object

Returns the value of attribute session_id.



327
328
329
 
# File 'lib/claude_sdk/types.rb', line 327

def session_id
  @session_id
end

#settings ⇒ Object

path to settings JSON file



326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
 
# File 'lib/claude_sdk/types.rb', line 326

class ClaudeCodeOptions
  attr_accessor :allowed_tools,
    :max_thinking_tokens,
    :system_prompt,
    :append_system_prompt,
    :mcp_tools,
    :mcp_servers,
    :permission_mode,
    :continue_conversation,
    :resume,
    :max_turns,
    :disallowed_tools,
    :model,
    :permission_prompt_tool_name,
    :cwd,
    :session_id,
    :settings

  # Initialize with default values
  #
  # @param allowed_tools [Array<String>] allowed tools (default: [])
  # @param max_thinking_tokens [Integer] max thinking tokens (default: 8000)
  # @param system_prompt [String, nil] system prompt
  # @param append_system_prompt [String, nil] append to system prompt
  # @param mcp_tools [Array<String>] MCP tools (default: [])
  # @param mcp_servers [Hash] MCP servers (default: {})
  # @param permission_mode [Symbol, nil] permission mode
  # @param continue_conversation [Boolean] continue conversation (default: false)
  # @param resume [String, nil] resume session ID
  # @param max_turns [Integer, nil] max turns
  # @param disallowed_tools [Array<String>] disallowed tools (default: [])
  # @param model [String, nil] model name
  # @param permission_prompt_tool_name [String, nil] permission tool
  # @param cwd [String, Pathname, nil] working directory
  # @param session_id [String, nil] session ID (must be a valid UUID)
  # @param settings [String, Pathname, nil] path to settings JSON file
  def initialize(allowed_tools: [],
    max_thinking_tokens: 8000,
    system_prompt: nil,
    append_system_prompt: nil,
    mcp_tools: [],
    mcp_servers: {},
    permission_mode: nil,
    continue_conversation: false,
    resume: nil,
    max_turns: nil,
    disallowed_tools: [],
    model: nil,
    permission_prompt_tool_name: nil,
    cwd: nil,
    session_id: nil,
    settings: nil)
    @allowed_tools = allowed_tools
    @max_thinking_tokens = max_thinking_tokens
    @system_prompt = system_prompt
    @append_system_prompt = append_system_prompt
    @mcp_tools = mcp_tools
    @mcp_servers = mcp_servers
    @permission_mode = permission_mode
    @continue_conversation = continue_conversation
    @resume = resume
    @max_turns = max_turns
    @disallowed_tools = disallowed_tools
    @model = model
    @permission_prompt_tool_name = permission_prompt_tool_name
    @cwd = cwd
    @session_id = session_id
    @settings = settings

    validate_permission_mode! if permission_mode
  end

  # Convert to hash for JSON serialization
  #
  # @return [Hash]
  def to_h
    hash = {}
    hash[:allowed_tools] = allowed_tools unless allowed_tools.empty?
    hash[:max_thinking_tokens] = max_thinking_tokens if max_thinking_tokens != 8000
    hash[:system_prompt] = system_prompt if system_prompt
    hash[:append_system_prompt] = append_system_prompt if append_system_prompt
    hash[:mcp_tools] = mcp_tools unless mcp_tools.empty?
    hash[:mcp_servers] = serialize_mcp_servers unless mcp_servers.empty?
    hash[:permission_mode] = permission_mode.to_s if permission_mode
    hash[:continue_conversation] = continue_conversation if continue_conversation
    hash[:resume] = resume if resume
    hash[:max_turns] = max_turns if max_turns
    hash[:disallowed_tools] = disallowed_tools unless disallowed_tools.empty?
    hash[:model] = model if model
    hash[:permission_prompt_tool_name] = permission_prompt_tool_name if permission_prompt_tool_name
    hash[:cwd] = cwd.to_s if cwd
    hash[:session_id] = session_id if session_id
    hash[:settings] = settings.to_s if settings
    hash
  end

  private

  # Validate permission mode
  def validate_permission_mode!
    return if PermissionMode.valid?(@permission_mode)

    raise ArgumentError, "Invalid permission mode: #{@permission_mode}"
  end

  # Serialize MCP servers to hashes
  def serialize_mcp_servers
    mcp_servers.transform_values do |server|
      server.respond_to?(:to_h) ? server.to_h : server
    end
  end
end

#system_prompt ⇒ Object

system prompt override



326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
 
# File 'lib/claude_sdk/types.rb', line 326

class ClaudeCodeOptions
  attr_accessor :allowed_tools,
    :max_thinking_tokens,
    :system_prompt,
    :append_system_prompt,
    :mcp_tools,
    :mcp_servers,
    :permission_mode,
    :continue_conversation,
    :resume,
    :max_turns,
    :disallowed_tools,
    :model,
    :permission_prompt_tool_name,
    :cwd,
    :session_id,
    :settings

  # Initialize with default values
  #
  # @param allowed_tools [Array<String>] allowed tools (default: [])
  # @param max_thinking_tokens [Integer] max thinking tokens (default: 8000)
  # @param system_prompt [String, nil] system prompt
  # @param append_system_prompt [String, nil] append to system prompt
  # @param mcp_tools [Array<String>] MCP tools (default: [])
  # @param mcp_servers [Hash] MCP servers (default: {})
  # @param permission_mode [Symbol, nil] permission mode
  # @param continue_conversation [Boolean] continue conversation (default: false)
  # @param resume [String, nil] resume session ID
  # @param max_turns [Integer, nil] max turns
  # @param disallowed_tools [Array<String>] disallowed tools (default: [])
  # @param model [String, nil] model name
  # @param permission_prompt_tool_name [String, nil] permission tool
  # @param cwd [String, Pathname, nil] working directory
  # @param session_id [String, nil] session ID (must be a valid UUID)
  # @param settings [String, Pathname, nil] path to settings JSON file
  def initialize(allowed_tools: [],
    max_thinking_tokens: 8000,
    system_prompt: nil,
    append_system_prompt: nil,
    mcp_tools: [],
    mcp_servers: {},
    permission_mode: nil,
    continue_conversation: false,
    resume: nil,
    max_turns: nil,
    disallowed_tools: [],
    model: nil,
    permission_prompt_tool_name: nil,
    cwd: nil,
    session_id: nil,
    settings: nil)
    @allowed_tools = allowed_tools
    @max_thinking_tokens = max_thinking_tokens
    @system_prompt = system_prompt
    @append_system_prompt = append_system_prompt
    @mcp_tools = mcp_tools
    @mcp_servers = mcp_servers
    @permission_mode = permission_mode
    @continue_conversation = continue_conversation
    @resume = resume
    @max_turns = max_turns
    @disallowed_tools = disallowed_tools
    @model = model
    @permission_prompt_tool_name = permission_prompt_tool_name
    @cwd = cwd
    @session_id = session_id
    @settings = settings

    validate_permission_mode! if permission_mode
  end

  # Convert to hash for JSON serialization
  #
  # @return [Hash]
  def to_h
    hash = {}
    hash[:allowed_tools] = allowed_tools unless allowed_tools.empty?
    hash[:max_thinking_tokens] = max_thinking_tokens if max_thinking_tokens != 8000
    hash[:system_prompt] = system_prompt if system_prompt
    hash[:append_system_prompt] = append_system_prompt if append_system_prompt
    hash[:mcp_tools] = mcp_tools unless mcp_tools.empty?
    hash[:mcp_servers] = serialize_mcp_servers unless mcp_servers.empty?
    hash[:permission_mode] = permission_mode.to_s if permission_mode
    hash[:continue_conversation] = continue_conversation if continue_conversation
    hash[:resume] = resume if resume
    hash[:max_turns] = max_turns if max_turns
    hash[:disallowed_tools] = disallowed_tools unless disallowed_tools.empty?
    hash[:model] = model if model
    hash[:permission_prompt_tool_name] = permission_prompt_tool_name if permission_prompt_tool_name
    hash[:cwd] = cwd.to_s if cwd
    hash[:session_id] = session_id if session_id
    hash[:settings] = settings.to_s if settings
    hash
  end

  private

  # Validate permission mode
  def validate_permission_mode!
    return if PermissionMode.valid?(@permission_mode)

    raise ArgumentError, "Invalid permission mode: #{@permission_mode}"
  end

  # Serialize MCP servers to hashes
  def serialize_mcp_servers
    mcp_servers.transform_values do |server|
      server.respond_to?(:to_h) ? server.to_h : server
    end
  end
end

Instance Method Details

#serialize_mcp_servers ⇒ Object (private)

Serialize MCP servers to hashes



432
433
434
435
436
 
# File 'lib/claude_sdk/types.rb', line 432

def serialize_mcp_servers
  mcp_servers.transform_values do |server|
    server.respond_to?(:to_h) ? server.to_h : server
  end
end

#to_h ⇒ Hash

Convert to hash for JSON serialization

Returns:

  • (Hash) 


401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
 
# File 'lib/claude_sdk/types.rb', line 401

def to_h
  hash = {}
  hash[:allowed_tools] = allowed_tools unless allowed_tools.empty?
  hash[:max_thinking_tokens] = max_thinking_tokens if max_thinking_tokens != 8000
  hash[:system_prompt] = system_prompt if system_prompt
  hash[:append_system_prompt] = append_system_prompt if append_system_prompt
  hash[:mcp_tools] = mcp_tools unless mcp_tools.empty?
  hash[:mcp_servers] = serialize_mcp_servers unless mcp_servers.empty?
  hash[:permission_mode] = permission_mode.to_s if permission_mode
  hash[:continue_conversation] = continue_conversation if continue_conversation
  hash[:resume] = resume if resume
  hash[:max_turns] = max_turns if max_turns
  hash[:disallowed_tools] = disallowed_tools unless disallowed_tools.empty?
  hash[:model] = model if model
  hash[:permission_prompt_tool_name] = permission_prompt_tool_name if permission_prompt_tool_name
  hash[:cwd] = cwd.to_s if cwd
  hash[:session_id] = session_id if session_id
  hash[:settings] = settings.to_s if settings
  hash
end

#validate_permission_mode! ⇒ Object (private)

Validate permission mode

Raises:

  • (ArgumentError) 


425
426
427
428
429
 
# File 'lib/claude_sdk/types.rb', line 425

def validate_permission_mode!
  return if PermissionMode.valid?(@permission_mode)

  raise ArgumentError, "Invalid permission mode: #{@permission_mode}"
end