claude_agent 0.7.12 → 0.7.14

data/lib/claude_agent/messages.rb

@@ -1,835 +1,15 @@
 # frozen_string_literal: true
 
-module ClaudeAgent
-  # User message sent to Claude
-  #
-  # @example
-  #   msg = UserMessage.new(content: "Hello!", uuid: "abc-123", session_id: "session-abc")
-  #
-  UserMessage = Data.define(:content, :uuid, :session_id, :parent_tool_use_id) do
-    def initialize(content:, uuid: nil, session_id: nil, parent_tool_use_id: nil)
-      super
-    end
-
-    def type
-      :user
-    end
-
-    # Get text content if content is a string
-    # @return [String, nil]
-    def text
-      content.is_a?(String) ? content : nil
-    end
-
-    # Check if this is a replayed message
-    # @return [Boolean]
-    def replay?
-      false
-    end
-  end
-
-  # User message replay (TypeScript SDK parity)
-  #
-  # Sent when resuming a session with existing conversation history.
-  # These messages represent replayed user messages from a previous session.
-  #
-  # @example
-  #   msg = UserMessageReplay.new(
-  #     content: "Hello!",
-  #     uuid: "abc-123",
-  #     session_id: "session-abc",
-  #     is_replay: true
-  #   )
-  #   msg.replay?  # => true
-  #
-  UserMessageReplay = Data.define(
-    :content,
-    :uuid,
-    :session_id,
-    :parent_tool_use_id,
-    :is_replay,
-    :is_synthetic,
-    :tool_use_result
-  ) do
-    def initialize(
-      content:,
-      uuid: nil,
-      session_id: nil,
-      parent_tool_use_id: nil,
-      is_replay: true,
-      is_synthetic: nil,
-      tool_use_result: nil
-    )
-      super
-    end
-
-    def type
-      :user
-    end
-
-    # Get text content if content is a string
-    # @return [String, nil]
-    def text
-      content.is_a?(String) ? content : nil
-    end
-
-    # Check if this is a replayed message
-    # @return [Boolean]
-    def replay?
-      is_replay == true
-    end
-
-    # Check if this is a synthetic message (system-generated)
-    # @return [Boolean]
-    def synthetic?
-      is_synthetic == true
-    end
-  end
-
-  # Assistant message from Claude
-  #
-  # @example
-  #   msg = AssistantMessage.new(
-  #     content: [TextBlock.new(text: "Hello!")],
-  #     model: "claude-sonnet-4-5-20250514",
-  #     uuid: "msg-123",
-  #     session_id: "session-abc"
-  #   )
-  #
-  AssistantMessage = Data.define(:content, :model, :uuid, :session_id, :error, :parent_tool_use_id) do
-    def initialize(content:, model:, uuid: nil, session_id: nil, error: nil, parent_tool_use_id: nil)
-      super
-    end
-
-    def type
-      :assistant
-    end
-
-    # Get all text content concatenated
-    # @return [String]
-    def text
-      content
-        .select { |block| block.is_a?(TextBlock) }
-        .map(&:text)
-        .join
-    end
-
-    # Get all thinking content concatenated
-    # @return [String]
-    def thinking
-      content
-        .select { |block| block.is_a?(ThinkingBlock) }
-        .map(&:thinking)
-        .join
-    end
-
-    # Get all tool use blocks
-    # @return [Array<ToolUseBlock>]
-    def tool_uses
-      content.select { |block| block.is_a?(ToolUseBlock) }
-    end
-
-    # Check if assistant wants to use a tool
-    # @return [Boolean]
-    def has_tool_use?
-      content.any? { |block| block.is_a?(ToolUseBlock) }
-    end
-  end
-
-  # System message (internal events)
-  #
-  # @example
-  #   msg = SystemMessage.new(subtype: "init", data: {version: "2.0.0"})
-  #
-  SystemMessage = Data.define(:subtype, :data) do
-    def type
-      :system
-    end
-  end
-
-  # Result message (final message with usage/cost info) - TypeScript SDK parity
-  #
-  # @example Success result
-  #   msg = ResultMessage.new(
-  #     subtype: "success",
-  #     duration_ms: 1500,
-  #     duration_api_ms: 1200,
-  #     is_error: false,
-  #     num_turns: 3,
-  #     session_id: "session-abc",
-  #     total_cost_usd: 0.05,
-  #     usage: {input_tokens: 100, output_tokens: 50}
-  #   )
-  #
-  # @example Error result
-  #   msg = ResultMessage.new(
-  #     subtype: "error_max_turns",
-  #     errors: ["Maximum turns exceeded"],
-  #     ...
-  #   )
-  #
-  ResultMessage = Data.define(
-    :subtype,
-    :duration_ms,
-    :duration_api_ms,
-    :is_error,
-    :num_turns,
-    :session_id,
-    :uuid,
-    :total_cost_usd,
-    :usage,
-    :result,
-    :structured_output,
-    :errors,             # Array<String> for error subtypes
-    :permission_denials, # Array<SDKPermissionDenial>
-    :model_usage,        # Hash with per-model usage breakdown
-    :stop_reason         # Why the model stopped generating (TypeScript SDK parity)
-  ) do
-    def initialize(
-      subtype:,
-      duration_ms:,
-      duration_api_ms:,
-      is_error:,
-      num_turns:,
-      session_id:,
-      uuid: nil,
-      total_cost_usd: nil,
-      usage: nil,
-      result: nil,
-      structured_output: nil,
-      errors: nil,
-      permission_denials: nil,
-      model_usage: nil,
-      stop_reason: nil
-    )
-      super
-    end
-
-    def type
-      :result
-    end
-
-    # Check if this was an error result
-    # @return [Boolean]
-    def error?
-      is_error
-    end
-
-    # Check if this was a successful result
-    # @return [Boolean]
-    def success?
-      !is_error
-    end
-  end
-
-  # Stream event (partial message during streaming)
-  #
-  # @example
-  #   event = StreamEvent.new(
-  #     uuid: "evt-123",
-  #     session_id: "session-abc",
-  #     event: {type: "content_block_delta", delta: {type: "text_delta", text: "Hello"}}
-  #   )
-  #
-  StreamEvent = Data.define(:uuid, :session_id, :event, :parent_tool_use_id) do
-    def initialize(uuid:, session_id:, event:, parent_tool_use_id: nil)
-      super
-    end
-
-    def type
-      :stream_event
-    end
-
-    # Get the event type from the raw event
-    # @return [String, nil]
-    def event_type
-      event[:type]
-    end
-  end
-
-  # Compact boundary message (conversation compaction marker) - TypeScript SDK parity
-  #
-  # Sent when the conversation is compacted to reduce context size.
-  # Contains metadata about the compaction operation.
-  #
-  # @example
-  #   msg = CompactBoundaryMessage.new(
-  #     uuid: "msg-123",
-  #     session_id: "session-abc",
-  #     compact_metadata: { trigger: "auto", pre_tokens: 50000 }
-  #   )
-  #   msg.trigger     # => "auto"
-  #   msg.pre_tokens  # => 50000
-  #
-  CompactBoundaryMessage = Data.define(:uuid, :session_id, :compact_metadata) do
-    def type
-      :compact_boundary
-    end
-
-    # Get the compaction trigger type
-    # @return [String] "manual" or "auto"
-    def trigger
-      compact_metadata[:trigger]
-    end
-
-    # Get the token count before compaction
-    # @return [Integer, nil]
-    def pre_tokens
-      compact_metadata[:pre_tokens]
-    end
-  end
-
-  # Status message (TypeScript SDK parity)
-  #
-  # Reports session status like 'compacting' during operations.
-  #
-  # @example
-  #   msg = StatusMessage.new(
-  #     uuid: "msg-123",
-  #     session_id: "session-abc",
-  #     status: "compacting"
-  #   )
-  #
-  StatusMessage = Data.define(:uuid, :session_id, :status, :permission_mode) do
-    def initialize(uuid:, session_id:, status:, permission_mode: nil)
-      super
-    end
-
-    def type
-      :status
-    end
-  end
-
-  # Tool progress message (TypeScript SDK parity)
-  #
-  # Reports progress during long-running tool executions.
-  #
-  # @example
-  #   msg = ToolProgressMessage.new(
-  #     uuid: "msg-123",
-  #     session_id: "session-abc",
-  #     tool_use_id: "tool-456",
-  #     tool_name: "Bash",
-  #     elapsed_time_seconds: 5.2
-  #   )
-  #
-  ToolProgressMessage = Data.define(
-    :uuid,
-    :session_id,
-    :tool_use_id,
-    :tool_name,
-    :parent_tool_use_id,
-    :elapsed_time_seconds,
-    :task_id
-  ) do
-    def initialize(
-      uuid:,
-      session_id:,
-      tool_use_id:,
-      tool_name:,
-      elapsed_time_seconds:,
-      parent_tool_use_id: nil,
-      task_id: nil
-    )
-      super
-    end
-
-    def type
-      :tool_progress
-    end
-  end
-
-  # Hook response message (TypeScript SDK parity)
-  #
-  # Contains output from hook executions.
-  #
-  # @example
-  #   msg = HookResponseMessage.new(
-  #     uuid: "msg-123",
-  #     session_id: "session-abc",
-  #     hook_id: "hook-456",
-  #     hook_name: "my-hook",
-  #     hook_event: "PreToolUse",
-  #     stdout: "Hook output",
-  #     stderr: "",
-  #     output: "Combined output",
-  #     exit_code: 0,
-  #     outcome: "success"
-  #   )
-  #   msg.success?    # => true
-  #   msg.error?      # => false
-  #   msg.cancelled?  # => false
-  #
-  # Outcome values:
-  # - "success" - Hook completed successfully
-  # - "error" - Hook encountered an error
-  # - "cancelled" - Hook was cancelled
-  #
-  HookResponseMessage = Data.define(
-    :uuid,
-    :session_id,
-    :hook_id,
-    :hook_name,
-    :hook_event,
-    :stdout,
-    :stderr,
-    :output,
-    :exit_code,
-    :outcome
-  ) do
-    def initialize(
-      uuid:,
-      session_id:,
-      hook_id: nil,
-      hook_name:,
-      hook_event:,
-      stdout: "",
-      stderr: "",
-      output: "",
-      exit_code: nil,
-      outcome: nil
-    )
-      super
-    end
-
-    def type
-      :hook_response
-    end
-
-    # Check if hook completed successfully
-    # @return [Boolean]
-    def success?
-      outcome == "success"
-    end
-
-    # Check if hook encountered an error
-    # @return [Boolean]
-    def error?
-      outcome == "error"
-    end
-
-    # Check if hook was cancelled
-    # @return [Boolean]
-    def cancelled?
-      outcome == "cancelled"
-    end
-  end
-
-  # Auth status message (TypeScript SDK parity)
-  #
-  # Reports authentication status during login flows.
-  #
-  # @example
-  #   msg = AuthStatusMessage.new(
-  #     uuid: "msg-123",
-  #     session_id: "session-abc",
-  #     is_authenticating: true,
-  #     output: ["Waiting for browser..."]
-  #   )
-  #
-  AuthStatusMessage = Data.define(
-    :uuid,
-    :session_id,
-    :is_authenticating,
-    :output,
-    :error
-  ) do
-    def initialize(
-      uuid:,
-      session_id:,
-      is_authenticating:,
-      output: [],
-      error: nil
-    )
-      super
-    end
-
-    def type
-      :auth_status
-    end
-  end
-
-  # Task notification message (TypeScript SDK parity)
-  #
-  # Sent when a background task completes, fails, or is stopped.
-  # Used for tracking async task execution status.
-  #
-  # @example
-  #   msg = TaskNotificationMessage.new(
-  #     uuid: "msg-123",
-  #     session_id: "session-abc",
-  #     task_id: "task-456",
-  #     status: "completed",
-  #     output_file: "/path/to/output.txt",
-  #     summary: "Task completed successfully"
-  #   )
-  #   msg.completed?  # => true
-  #   msg.failed?     # => false
-  #
-  # Status values:
-  # - "completed" - Task finished successfully
-  # - "failed" - Task encountered an error
-  # - "stopped" - Task was manually stopped
-  #
-  TaskNotificationMessage = Data.define(
-    :uuid,
-    :session_id,
-    :task_id,
-    :status,
-    :output_file,
-    :summary,
-    :tool_use_id,
-    :usage
-  ) do
-    def initialize(
-      uuid:,
-      session_id:,
-      task_id:,
-      status:,
-      output_file:,
-      summary:,
-      tool_use_id: nil,
-      usage: nil
-    )
-      super
-    end
-
-    def type
-      :task_notification
-    end
-
-    # Check if task completed successfully
-    # @return [Boolean]
-    def completed?
-      status == "completed"
-    end
-
-    # Check if task failed
-    # @return [Boolean]
-    def failed?
-      status == "failed"
-    end
-
-    # Check if task was stopped
-    # @return [Boolean]
-    def stopped?
-      status == "stopped"
-    end
-  end
-
-  # Hook started message (TypeScript SDK parity)
-  #
-  # Sent when a hook execution starts.
-  #
-  # @example
-  #   msg = HookStartedMessage.new(
-  #     uuid: "msg-123",
-  #     session_id: "session-abc",
-  #     hook_id: "hook-456",
-  #     hook_name: "my-hook",
-  #     hook_event: "PreToolUse"
-  #   )
-  #
-  HookStartedMessage = Data.define(
-    :uuid,
-    :session_id,
-    :hook_id,
-    :hook_name,
-    :hook_event
-  ) do
-    def initialize(
-      uuid:,
-      session_id:,
-      hook_id:,
-      hook_name:,
-      hook_event:
-    )
-      super
-    end
-
-    def type
-      :hook_started
-    end
-  end
-
-  # Hook progress message (TypeScript SDK parity)
-  #
-  # Reports progress during hook execution.
-  #
-  # @example
-  #   msg = HookProgressMessage.new(
-  #     uuid: "msg-123",
-  #     session_id: "session-abc",
-  #     hook_id: "hook-456",
-  #     hook_name: "my-hook",
-  #     hook_event: "PreToolUse",
-  #     stdout: "Hook output so far...",
-  #     stderr: "",
-  #     output: "Combined output"
-  #   )
-  #
-  HookProgressMessage = Data.define(
-    :uuid,
-    :session_id,
-    :hook_id,
-    :hook_name,
-    :hook_event,
-    :stdout,
-    :stderr,
-    :output
-  ) do
-    def initialize(
-      uuid:,
-      session_id:,
-      hook_id:,
-      hook_name:,
-      hook_event:,
-      stdout: "",
-      stderr: "",
-      output: ""
-    )
-      super
-    end
-
-    def type
-      :hook_progress
-    end
-  end
-
-  # Tool use summary message (TypeScript SDK parity)
-  #
-  # Contains a summary of tool use for collapsed display.
-  #
-  # @example
-  #   msg = ToolUseSummaryMessage.new(
-  #     uuid: "msg-123",
-  #     session_id: "session-abc",
-  #     summary: "Read 3 files",
-  #     preceding_tool_use_ids: ["tool-1", "tool-2", "tool-3"]
-  #   )
-  #
-  ToolUseSummaryMessage = Data.define(
-    :uuid,
-    :session_id,
-    :summary,
-    :preceding_tool_use_ids
-  ) do
-    def initialize(
-      uuid:,
-      session_id:,
-      summary:,
-      preceding_tool_use_ids: []
-    )
-      super
-    end
-
-    def type
-      :tool_use_summary
-    end
-  end
-
-  # Task started message (TypeScript SDK v0.2.45 parity)
-  #
-  # Sent when a new task (subagent) is started.
-  #
-  # @example
-  #   msg = TaskStartedMessage.new(
-  #     uuid: "msg-123",
-  #     session_id: "session-abc",
-  #     task_id: "task-456",
-  #     tool_use_id: "tool-789",
-  #     description: "Running tests",
-  #     task_type: "bash"
-  #   )
-  #
-  TaskStartedMessage = Data.define(
-    :uuid,
-    :session_id,
-    :task_id,
-    :tool_use_id,
-    :description,
-    :task_type
-  ) do
-    def initialize(
-      uuid:,
-      session_id:,
-      task_id:,
-      tool_use_id: nil,
-      description: nil,
-      task_type: nil
-    )
-      super
-    end
-
-    def type
-      :task_started
-    end
-  end
-
-  # Task progress message (TypeScript SDK v0.2.51 parity)
-  #
-  # Reports progress during background task (subagent) execution.
-  # Contains usage information and description of what the task is doing.
-  #
-  # @example
-  #   msg = TaskProgressMessage.new(
-  #     uuid: "msg-123",
-  #     session_id: "session-abc",
-  #     task_id: "task-456",
-  #     description: "Searching codebase for patterns",
-  #     usage: { total_tokens: 5000, tool_uses: 3, duration_ms: 2500 }
-  #   )
-  #
-  TaskProgressMessage = Data.define(
-    :uuid, :session_id, :task_id, :tool_use_id,
-    :description, :usage, :last_tool_name
-  ) do
-    def initialize(
-      uuid:,
-      session_id:,
-      task_id:,
-      description:,
-      usage: nil,
-      tool_use_id: nil,
-      last_tool_name: nil
-    )
-      super
-    end
-
-    def type
-      :task_progress
-    end
-  end
-
-  # Rate limit event (TypeScript SDK v0.2.45 parity)
-  #
-  # Reports rate limit status and utilization information.
-  #
-  # @example
-  #   msg = RateLimitEvent.new(
-  #     uuid: "msg-123",
-  #     session_id: "session-abc",
-  #     rate_limit_info: {
-  #       status: "allowed_warning",
-  #       resetsAt: 1700000000,
-  #       rateLimitType: "five_hour",
-  #       utilization: 0.85,
-  #       isUsingOverage: false,
-  #       overageStatus: "available"
-  #     }
-  #   )
-  #   msg.status  # => "allowed_warning"
-  #
-  RateLimitEvent = Data.define(:rate_limit_info, :uuid, :session_id) do
-    def initialize(rate_limit_info:, uuid: nil, session_id: nil)
-      super
-    end
-
-    def type
-      :rate_limit_event
-    end
-
-    # Get the rate limit status
-    # @return [String, nil]
-    def status
-      rate_limit_info[:status]
-    end
-  end
-
-  # Prompt suggestion message (TypeScript SDK v0.2.47 parity)
-  #
-  # Contains a suggested prompt for the user.
-  #
-  # @example
-  #   msg = PromptSuggestionMessage.new(
-  #     uuid: "msg-123",
-  #     session_id: "session-abc",
-  #     suggestion: "Tell me about this project"
-  #   )
-  #
-  PromptSuggestionMessage = Data.define(:uuid, :session_id, :suggestion) do
-    def initialize(uuid: nil, session_id: nil, suggestion:)
-      super
-    end
-
-    def type
-      :prompt_suggestion
-    end
-  end
-
-  # Files persisted event (TypeScript SDK v0.2.25 parity)
-  #
-  # Sent when files are persisted to storage during a session.
-  # Contains lists of successfully persisted files and any failures.
-  #
-  # @example
-  #   msg = FilesPersistedEvent.new(
-  #     uuid: "msg-123",
-  #     session_id: "session-abc",
-  #     files: [{ filename: "test.rb", file_id: "file-456" }],
-  #     failed: [],
-  #     processed_at: "2026-01-30T12:00:00Z"
-  #   )
-  #   msg.files.first[:filename]  # => "test.rb"
-  #
-  FilesPersistedEvent = Data.define(
-    :uuid,
-    :session_id,
-    :files,
-    :failed,
-    :processed_at
-  ) do
-    def initialize(
-      uuid:,
-      session_id:,
-      files: [],
-      failed: [],
-      processed_at: nil
-    )
-      super
-    end
-
-    def type
-      :files_persisted
-    end
-  end
-
-  # Generic message for unknown/future protocol types
-  #
-  # Wraps unrecognized top-level message types so they can be inspected
-  # without crashing the application. Supports dynamic field access via
-  # `[]` and `method_missing`.
-  #
-  # @example
-  #   msg = GenericMessage.new(message_type: "fancy_new", raw: { data: "hello" })
-  #   msg.type       # => :fancy_new
-  #   msg[:data]     # => "hello"
-  #   msg.data       # => "hello"
-  #   msg.to_h       # => { data: "hello" }
-  #
-  GenericMessage = Data.define(:message_type, :raw) do
-    def type
-      message_type&.to_sym || :unknown
-    end
-
-    def to_h
-      raw
-    end
-
-    def [](key)
-      raw[key]
-    end
-
-    def respond_to_missing?(name, include_private = false)
-      raw.key?(name) || super
-    end
-
-    def method_missing(name, *args)
-      return raw[name] if args.empty? && raw.key?(name)
-      super
-    end
-  end
+require_relative "messages/conversation"
+require_relative "messages/result"
+require_relative "messages/system"
+require_relative "messages/streaming"
+require_relative "messages/tool_lifecycle"
+require_relative "messages/hook_lifecycle"
+require_relative "messages/task_lifecycle"
+require_relative "messages/generic"
 
+module ClaudeAgent
   # All message types
   MESSAGE_TYPES = [
     UserMessage,
@@ -852,6 +32,8 @@ module ClaudeAgent
     TaskProgressMessage,
     RateLimitEvent,
     PromptSuggestionMessage,
+    ElicitationCompleteMessage,
+    LocalCommandOutputMessage,
     GenericMessage
   ].freeze
 end