cerca 0.1.0

data/rbi/cerca/models/thread_stream_event.rbi

@@ -0,0 +1,1507 @@
+# typed: strong
+
+module Cerca
+  module Models
+    module ThreadStreamEvent
+      extend Cerca::Internal::Type::Union
+
+      Variants =
+        T.type_alias do
+          T.any(
+            Cerca::ThreadStreamEvent::ThreadStreamStatusMessage,
+            Cerca::ThreadStreamEvent::ThreadStreamContentMessage,
+            Cerca::ThreadStreamEvent::ThreadStreamProgressMessage,
+            Cerca::ThreadStreamEvent::ThreadStreamTurnStartedMessage,
+            Cerca::ThreadStreamEvent::ThreadStreamTurnCompletedMessage,
+            Cerca::ThreadStreamEvent::ThreadStreamItemStartedMessage,
+            Cerca::ThreadStreamEvent::ThreadStreamItemCompletedMessage,
+            Cerca::ThreadStreamEvent::ThreadStreamTokenUsageMessage,
+            Cerca::ThreadStreamEvent::ThreadStreamApprovalRequestedMessage,
+            Cerca::ThreadStreamEvent::ThreadStreamApprovalResolvedMessage
+          )
+        end
+
+      class ThreadStreamStatusMessage < Cerca::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              Cerca::ThreadStreamEvent::ThreadStreamStatusMessage,
+              Cerca::Internal::AnyHash
+            )
+          end
+
+        sig { returns(T.nilable(String)) }
+        attr_accessor :error
+
+        sig { returns(Float) }
+        attr_accessor :event_seq
+
+        sig { returns(T.nilable(String)) }
+        attr_accessor :result
+
+        # `idle` threads can accept a new turn or be closed. `running` threads have an
+        # active turn. `awaiting` threads are paused on external input such as approvals.
+        # `closed` threads are terminal.
+        sig { returns(Cerca::Status::TaggedSymbol) }
+        attr_accessor :status
+
+        sig { returns(Float) }
+        attr_accessor :step_seq
+
+        sig { returns(String) }
+        attr_accessor :turn_id
+
+        sig { returns(Symbol) }
+        attr_accessor :type
+
+        sig do
+          params(
+            error: T.nilable(String),
+            event_seq: Float,
+            result: T.nilable(String),
+            status: Cerca::Status::OrSymbol,
+            step_seq: Float,
+            turn_id: String,
+            type: Symbol
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          error:,
+          event_seq:,
+          result:,
+          # `idle` threads can accept a new turn or be closed. `running` threads have an
+          # active turn. `awaiting` threads are paused on external input such as approvals.
+          # `closed` threads are terminal.
+          status:,
+          step_seq:,
+          turn_id:,
+          type: :status
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              error: T.nilable(String),
+              event_seq: Float,
+              result: T.nilable(String),
+              status: Cerca::Status::TaggedSymbol,
+              step_seq: Float,
+              turn_id: String,
+              type: Symbol
+            }
+          )
+        end
+        def to_hash
+        end
+      end
+
+      class ThreadStreamContentMessage < Cerca::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              Cerca::ThreadStreamEvent::ThreadStreamContentMessage,
+              Cerca::Internal::AnyHash
+            )
+          end
+
+        sig { returns(Float) }
+        attr_accessor :event_seq
+
+        sig do
+          returns(Cerca::ThreadStreamEvent::ThreadStreamContentMessage::Message)
+        end
+        attr_reader :message
+
+        sig do
+          params(
+            message:
+              Cerca::ThreadStreamEvent::ThreadStreamContentMessage::Message::OrHash
+          ).void
+        end
+        attr_writer :message
+
+        sig { returns(Float) }
+        attr_accessor :step_seq
+
+        sig { returns(String) }
+        attr_accessor :turn_id
+
+        sig { returns(Symbol) }
+        attr_accessor :type
+
+        sig do
+          params(
+            event_seq: Float,
+            message:
+              Cerca::ThreadStreamEvent::ThreadStreamContentMessage::Message::OrHash,
+            step_seq: Float,
+            turn_id: String,
+            type: Symbol
+          ).returns(T.attached_class)
+        end
+        def self.new(event_seq:, message:, step_seq:, turn_id:, type: :message)
+        end
+
+        sig do
+          override.returns(
+            {
+              event_seq: Float,
+              message:
+                Cerca::ThreadStreamEvent::ThreadStreamContentMessage::Message,
+              step_seq: Float,
+              turn_id: String,
+              type: Symbol
+            }
+          )
+        end
+        def to_hash
+        end
+
+        class Message < Cerca::Internal::Type::BaseModel
+          OrHash =
+            T.type_alias do
+              T.any(
+                Cerca::ThreadStreamEvent::ThreadStreamContentMessage::Message,
+                Cerca::Internal::AnyHash
+              )
+            end
+
+          sig do
+            returns(
+              T::Array[
+                Cerca::ThreadStreamEvent::ThreadStreamContentMessage::Message::Content::Variants
+              ]
+            )
+          end
+          attr_accessor :content
+
+          sig { returns(String) }
+          attr_accessor :created_at
+
+          sig do
+            returns(
+              Cerca::ThreadStreamEvent::ThreadStreamContentMessage::Message::Role::TaggedSymbol
+            )
+          end
+          attr_accessor :role
+
+          sig { returns(Float) }
+          attr_accessor :seq
+
+          sig do
+            params(
+              content:
+                T::Array[
+                  T.any(
+                    Cerca::ThreadStreamEvent::ThreadStreamContentMessage::Message::Content::Text::OrHash,
+                    Cerca::ThreadStreamEvent::ThreadStreamContentMessage::Message::Content::ToolUse::OrHash,
+                    Cerca::ThreadStreamEvent::ThreadStreamContentMessage::Message::Content::ToolResult::OrHash,
+                    Cerca::ThreadStreamEvent::ThreadStreamContentMessage::Message::Content::ServerToolUse::OrHash,
+                    Cerca::ThreadStreamEvent::ThreadStreamContentMessage::Message::Content::WebSearchToolResult::OrHash
+                  )
+                ],
+              created_at: String,
+              role:
+                Cerca::ThreadStreamEvent::ThreadStreamContentMessage::Message::Role::OrSymbol,
+              seq: Float
+            ).returns(T.attached_class)
+          end
+          def self.new(content:, created_at:, role:, seq:)
+          end
+
+          sig do
+            override.returns(
+              {
+                content:
+                  T::Array[
+                    Cerca::ThreadStreamEvent::ThreadStreamContentMessage::Message::Content::Variants
+                  ],
+                created_at: String,
+                role:
+                  Cerca::ThreadStreamEvent::ThreadStreamContentMessage::Message::Role::TaggedSymbol,
+                seq: Float
+              }
+            )
+          end
+          def to_hash
+          end
+
+          module Content
+            extend Cerca::Internal::Type::Union
+
+            Variants =
+              T.type_alias do
+                T.any(
+                  Cerca::ThreadStreamEvent::ThreadStreamContentMessage::Message::Content::Text,
+                  Cerca::ThreadStreamEvent::ThreadStreamContentMessage::Message::Content::ToolUse,
+                  Cerca::ThreadStreamEvent::ThreadStreamContentMessage::Message::Content::ToolResult,
+                  Cerca::ThreadStreamEvent::ThreadStreamContentMessage::Message::Content::ServerToolUse,
+                  Cerca::ThreadStreamEvent::ThreadStreamContentMessage::Message::Content::WebSearchToolResult
+                )
+              end
+
+            class Text < Cerca::Internal::Type::BaseModel
+              OrHash =
+                T.type_alias do
+                  T.any(
+                    Cerca::ThreadStreamEvent::ThreadStreamContentMessage::Message::Content::Text,
+                    Cerca::Internal::AnyHash
+                  )
+                end
+
+              sig { returns(String) }
+              attr_accessor :text
+
+              sig { returns(Symbol) }
+              attr_accessor :type
+
+              sig do
+                returns(T.nilable(T::Hash[Symbol, T::Hash[Symbol, String]]))
+              end
+              attr_reader :provider_metadata
+
+              sig do
+                params(
+                  provider_metadata: T::Hash[Symbol, T::Hash[Symbol, String]]
+                ).void
+              end
+              attr_writer :provider_metadata
+
+              sig do
+                params(
+                  text: String,
+                  provider_metadata: T::Hash[Symbol, T::Hash[Symbol, String]],
+                  type: Symbol
+                ).returns(T.attached_class)
+              end
+              def self.new(text:, provider_metadata: nil, type: :text)
+              end
+
+              sig do
+                override.returns(
+                  {
+                    text: String,
+                    type: Symbol,
+                    provider_metadata: T::Hash[Symbol, T::Hash[Symbol, String]]
+                  }
+                )
+              end
+              def to_hash
+              end
+            end
+
+            class ToolUse < Cerca::Internal::Type::BaseModel
+              OrHash =
+                T.type_alias do
+                  T.any(
+                    Cerca::ThreadStreamEvent::ThreadStreamContentMessage::Message::Content::ToolUse,
+                    Cerca::Internal::AnyHash
+                  )
+                end
+
+              sig { returns(String) }
+              attr_accessor :id
+
+              # JSON-serialized tool input payload. Parse as JSON before reading tool-specific
+              # fields.
+              sig { returns(String) }
+              attr_accessor :input
+
+              sig { returns(Cerca::ToolName::TaggedSymbol) }
+              attr_accessor :name
+
+              sig { returns(Symbol) }
+              attr_accessor :type
+
+              sig do
+                returns(T.nilable(T::Hash[Symbol, T::Hash[Symbol, String]]))
+              end
+              attr_reader :provider_metadata
+
+              sig do
+                params(
+                  provider_metadata: T::Hash[Symbol, T::Hash[Symbol, String]]
+                ).void
+              end
+              attr_writer :provider_metadata
+
+              sig do
+                params(
+                  id: String,
+                  input: String,
+                  name: Cerca::ToolName::OrSymbol,
+                  provider_metadata: T::Hash[Symbol, T::Hash[Symbol, String]],
+                  type: Symbol
+                ).returns(T.attached_class)
+              end
+              def self.new(
+                id:,
+                # JSON-serialized tool input payload. Parse as JSON before reading tool-specific
+                # fields.
+                input:,
+                name:,
+                provider_metadata: nil,
+                type: :tool_use
+              )
+              end
+
+              sig do
+                override.returns(
+                  {
+                    id: String,
+                    input: String,
+                    name: Cerca::ToolName::TaggedSymbol,
+                    type: Symbol,
+                    provider_metadata: T::Hash[Symbol, T::Hash[Symbol, String]]
+                  }
+                )
+              end
+              def to_hash
+              end
+            end
+
+            class ToolResult < Cerca::Internal::Type::BaseModel
+              OrHash =
+                T.type_alias do
+                  T.any(
+                    Cerca::ThreadStreamEvent::ThreadStreamContentMessage::Message::Content::ToolResult,
+                    Cerca::Internal::AnyHash
+                  )
+                end
+
+              sig { returns(String) }
+              attr_accessor :content
+
+              sig { returns(T::Boolean) }
+              attr_accessor :is_error
+
+              sig { returns(String) }
+              attr_accessor :tool_use_id
+
+              sig { returns(Symbol) }
+              attr_accessor :type
+
+              sig { returns(T.nilable(T::Boolean)) }
+              attr_reader :denied_by_user
+
+              sig { params(denied_by_user: T::Boolean).void }
+              attr_writer :denied_by_user
+
+              sig do
+                returns(T.nilable(T::Hash[Symbol, T::Hash[Symbol, String]]))
+              end
+              attr_reader :provider_metadata
+
+              sig do
+                params(
+                  provider_metadata: T::Hash[Symbol, T::Hash[Symbol, String]]
+                ).void
+              end
+              attr_writer :provider_metadata
+
+              sig do
+                params(
+                  content: String,
+                  is_error: T::Boolean,
+                  tool_use_id: String,
+                  denied_by_user: T::Boolean,
+                  provider_metadata: T::Hash[Symbol, T::Hash[Symbol, String]],
+                  type: Symbol
+                ).returns(T.attached_class)
+              end
+              def self.new(
+                content:,
+                is_error:,
+                tool_use_id:,
+                denied_by_user: nil,
+                provider_metadata: nil,
+                type: :tool_result
+              )
+              end
+
+              sig do
+                override.returns(
+                  {
+                    content: String,
+                    is_error: T::Boolean,
+                    tool_use_id: String,
+                    type: Symbol,
+                    denied_by_user: T::Boolean,
+                    provider_metadata: T::Hash[Symbol, T::Hash[Symbol, String]]
+                  }
+                )
+              end
+              def to_hash
+              end
+            end
+
+            class ServerToolUse < Cerca::Internal::Type::BaseModel
+              OrHash =
+                T.type_alias do
+                  T.any(
+                    Cerca::ThreadStreamEvent::ThreadStreamContentMessage::Message::Content::ServerToolUse,
+                    Cerca::Internal::AnyHash
+                  )
+                end
+
+              sig { returns(String) }
+              attr_accessor :id
+
+              # JSON-serialized tool input payload. Parse as JSON before reading tool-specific
+              # fields.
+              sig { returns(String) }
+              attr_accessor :input
+
+              sig { returns(String) }
+              attr_accessor :name
+
+              sig { returns(Symbol) }
+              attr_accessor :type
+
+              sig do
+                returns(T.nilable(T::Hash[Symbol, T::Hash[Symbol, String]]))
+              end
+              attr_reader :provider_metadata
+
+              sig do
+                params(
+                  provider_metadata: T::Hash[Symbol, T::Hash[Symbol, String]]
+                ).void
+              end
+              attr_writer :provider_metadata
+
+              sig do
+                params(
+                  id: String,
+                  input: String,
+                  name: String,
+                  provider_metadata: T::Hash[Symbol, T::Hash[Symbol, String]],
+                  type: Symbol
+                ).returns(T.attached_class)
+              end
+              def self.new(
+                id:,
+                # JSON-serialized tool input payload. Parse as JSON before reading tool-specific
+                # fields.
+                input:,
+                name:,
+                provider_metadata: nil,
+                type: :server_tool_use
+              )
+              end
+
+              sig do
+                override.returns(
+                  {
+                    id: String,
+                    input: String,
+                    name: String,
+                    type: Symbol,
+                    provider_metadata: T::Hash[Symbol, T::Hash[Symbol, String]]
+                  }
+                )
+              end
+              def to_hash
+              end
+            end
+
+            class WebSearchToolResult < Cerca::Internal::Type::BaseModel
+              OrHash =
+                T.type_alias do
+                  T.any(
+                    Cerca::ThreadStreamEvent::ThreadStreamContentMessage::Message::Content::WebSearchToolResult,
+                    Cerca::Internal::AnyHash
+                  )
+                end
+
+              # Web search result payload. The runtime returns either an array of web search
+              # results or an error object.
+              sig { returns(T.anything) }
+              attr_accessor :content
+
+              sig { returns(String) }
+              attr_accessor :tool_use_id
+
+              sig { returns(Symbol) }
+              attr_accessor :type
+
+              sig do
+                params(
+                  content: T.anything,
+                  tool_use_id: String,
+                  type: Symbol
+                ).returns(T.attached_class)
+              end
+              def self.new(
+                # Web search result payload. The runtime returns either an array of web search
+                # results or an error object.
+                content:,
+                tool_use_id:,
+                type: :web_search_tool_result
+              )
+              end
+
+              sig do
+                override.returns(
+                  { content: T.anything, tool_use_id: String, type: Symbol }
+                )
+              end
+              def to_hash
+              end
+            end
+
+            sig do
+              override.returns(
+                T::Array[
+                  Cerca::ThreadStreamEvent::ThreadStreamContentMessage::Message::Content::Variants
+                ]
+              )
+            end
+            def self.variants
+            end
+          end
+
+          module Role
+            extend Cerca::Internal::Type::Enum
+
+            TaggedSymbol =
+              T.type_alias do
+                T.all(
+                  Symbol,
+                  Cerca::ThreadStreamEvent::ThreadStreamContentMessage::Message::Role
+                )
+              end
+            OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+            USER =
+              T.let(
+                :user,
+                Cerca::ThreadStreamEvent::ThreadStreamContentMessage::Message::Role::TaggedSymbol
+              )
+            ASSISTANT =
+              T.let(
+                :assistant,
+                Cerca::ThreadStreamEvent::ThreadStreamContentMessage::Message::Role::TaggedSymbol
+              )
+
+            sig do
+              override.returns(
+                T::Array[
+                  Cerca::ThreadStreamEvent::ThreadStreamContentMessage::Message::Role::TaggedSymbol
+                ]
+              )
+            end
+            def self.values
+            end
+          end
+        end
+      end
+
+      class ThreadStreamProgressMessage < Cerca::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              Cerca::ThreadStreamEvent::ThreadStreamProgressMessage,
+              Cerca::Internal::AnyHash
+            )
+          end
+
+        sig { returns(Float) }
+        attr_accessor :event_seq
+
+        sig { returns(Float) }
+        attr_accessor :message_count
+
+        sig { returns(Float) }
+        attr_accessor :step_count
+
+        sig { returns(Float) }
+        attr_accessor :step_seq
+
+        sig { returns(String) }
+        attr_accessor :turn_id
+
+        sig { returns(Symbol) }
+        attr_accessor :type
+
+        sig do
+          params(
+            event_seq: Float,
+            message_count: Float,
+            step_count: Float,
+            step_seq: Float,
+            turn_id: String,
+            type: Symbol
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          event_seq:,
+          message_count:,
+          step_count:,
+          step_seq:,
+          turn_id:,
+          type: :progress
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              event_seq: Float,
+              message_count: Float,
+              step_count: Float,
+              step_seq: Float,
+              turn_id: String,
+              type: Symbol
+            }
+          )
+        end
+        def to_hash
+        end
+      end
+
+      class ThreadStreamTurnStartedMessage < Cerca::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              Cerca::ThreadStreamEvent::ThreadStreamTurnStartedMessage,
+              Cerca::Internal::AnyHash
+            )
+          end
+
+        sig { returns(Float) }
+        attr_accessor :event_seq
+
+        sig { returns(String) }
+        attr_accessor :turn_id
+
+        sig { returns(Float) }
+        attr_accessor :turn_seq
+
+        sig { returns(Symbol) }
+        attr_accessor :type
+
+        sig do
+          params(
+            event_seq: Float,
+            turn_id: String,
+            turn_seq: Float,
+            type: Symbol
+          ).returns(T.attached_class)
+        end
+        def self.new(event_seq:, turn_id:, turn_seq:, type: :"turn/started")
+        end
+
+        sig do
+          override.returns(
+            { event_seq: Float, turn_id: String, turn_seq: Float, type: Symbol }
+          )
+        end
+        def to_hash
+        end
+      end
+
+      class ThreadStreamTurnCompletedMessage < Cerca::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              Cerca::ThreadStreamEvent::ThreadStreamTurnCompletedMessage,
+              Cerca::Internal::AnyHash
+            )
+          end
+
+        sig { returns(T.nilable(String)) }
+        attr_accessor :error
+
+        sig { returns(Float) }
+        attr_accessor :event_seq
+
+        sig { returns(T.nilable(String)) }
+        attr_accessor :result
+
+        sig do
+          returns(
+            Cerca::ThreadStreamEvent::ThreadStreamTurnCompletedMessage::Status::TaggedSymbol
+          )
+        end
+        attr_accessor :status
+
+        sig { returns(String) }
+        attr_accessor :turn_id
+
+        sig { returns(Float) }
+        attr_accessor :turn_seq
+
+        sig { returns(Symbol) }
+        attr_accessor :type
+
+        sig do
+          params(
+            error: T.nilable(String),
+            event_seq: Float,
+            result: T.nilable(String),
+            status:
+              Cerca::ThreadStreamEvent::ThreadStreamTurnCompletedMessage::Status::OrSymbol,
+            turn_id: String,
+            turn_seq: Float,
+            type: Symbol
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          error:,
+          event_seq:,
+          result:,
+          status:,
+          turn_id:,
+          turn_seq:,
+          type: :"turn/completed"
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              error: T.nilable(String),
+              event_seq: Float,
+              result: T.nilable(String),
+              status:
+                Cerca::ThreadStreamEvent::ThreadStreamTurnCompletedMessage::Status::TaggedSymbol,
+              turn_id: String,
+              turn_seq: Float,
+              type: Symbol
+            }
+          )
+        end
+        def to_hash
+        end
+
+        module Status
+          extend Cerca::Internal::Type::Enum
+
+          TaggedSymbol =
+            T.type_alias do
+              T.all(
+                Symbol,
+                Cerca::ThreadStreamEvent::ThreadStreamTurnCompletedMessage::Status
+              )
+            end
+          OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+          COMPLETED =
+            T.let(
+              :completed,
+              Cerca::ThreadStreamEvent::ThreadStreamTurnCompletedMessage::Status::TaggedSymbol
+            )
+          FAILED =
+            T.let(
+              :failed,
+              Cerca::ThreadStreamEvent::ThreadStreamTurnCompletedMessage::Status::TaggedSymbol
+            )
+
+          sig do
+            override.returns(
+              T::Array[
+                Cerca::ThreadStreamEvent::ThreadStreamTurnCompletedMessage::Status::TaggedSymbol
+              ]
+            )
+          end
+          def self.values
+          end
+        end
+      end
+
+      class ThreadStreamItemStartedMessage < Cerca::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              Cerca::ThreadStreamEvent::ThreadStreamItemStartedMessage,
+              Cerca::Internal::AnyHash
+            )
+          end
+
+        sig { returns(Float) }
+        attr_accessor :event_seq
+
+        sig { returns(String) }
+        attr_accessor :item_id
+
+        sig do
+          returns(
+            Cerca::ThreadStreamEvent::ThreadStreamItemStartedMessage::ItemType::TaggedSymbol
+          )
+        end
+        attr_accessor :item_type
+
+        sig { returns(String) }
+        attr_accessor :turn_id
+
+        sig { returns(Symbol) }
+        attr_accessor :type
+
+        sig { returns(T.nilable(String)) }
+        attr_reader :requested_tool_name
+
+        sig { params(requested_tool_name: String).void }
+        attr_writer :requested_tool_name
+
+        sig { returns(T.nilable(String)) }
+        attr_reader :sub_thread_id
+
+        sig { params(sub_thread_id: String).void }
+        attr_writer :sub_thread_id
+
+        sig { returns(T.nilable(Cerca::ToolName::TaggedSymbol)) }
+        attr_reader :tool_name
+
+        sig { params(tool_name: Cerca::ToolName::OrSymbol).void }
+        attr_writer :tool_name
+
+        sig do
+          params(
+            event_seq: Float,
+            item_id: String,
+            item_type:
+              Cerca::ThreadStreamEvent::ThreadStreamItemStartedMessage::ItemType::OrSymbol,
+            turn_id: String,
+            requested_tool_name: String,
+            sub_thread_id: String,
+            tool_name: Cerca::ToolName::OrSymbol,
+            type: Symbol
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          event_seq:,
+          item_id:,
+          item_type:,
+          turn_id:,
+          requested_tool_name: nil,
+          sub_thread_id: nil,
+          tool_name: nil,
+          type: :"item/started"
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              event_seq: Float,
+              item_id: String,
+              item_type:
+                Cerca::ThreadStreamEvent::ThreadStreamItemStartedMessage::ItemType::TaggedSymbol,
+              turn_id: String,
+              type: Symbol,
+              requested_tool_name: String,
+              sub_thread_id: String,
+              tool_name: Cerca::ToolName::TaggedSymbol
+            }
+          )
+        end
+        def to_hash
+        end
+
+        module ItemType
+          extend Cerca::Internal::Type::Enum
+
+          TaggedSymbol =
+            T.type_alias do
+              T.all(
+                Symbol,
+                Cerca::ThreadStreamEvent::ThreadStreamItemStartedMessage::ItemType
+              )
+            end
+          OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+          TOOL_CALL =
+            T.let(
+              :tool_call,
+              Cerca::ThreadStreamEvent::ThreadStreamItemStartedMessage::ItemType::TaggedSymbol
+            )
+          AGENT_MESSAGE =
+            T.let(
+              :agent_message,
+              Cerca::ThreadStreamEvent::ThreadStreamItemStartedMessage::ItemType::TaggedSymbol
+            )
+          LLM_CALL =
+            T.let(
+              :llm_call,
+              Cerca::ThreadStreamEvent::ThreadStreamItemStartedMessage::ItemType::TaggedSymbol
+            )
+          SUB_THREAD =
+            T.let(
+              :sub_thread,
+              Cerca::ThreadStreamEvent::ThreadStreamItemStartedMessage::ItemType::TaggedSymbol
+            )
+
+          sig do
+            override.returns(
+              T::Array[
+                Cerca::ThreadStreamEvent::ThreadStreamItemStartedMessage::ItemType::TaggedSymbol
+              ]
+            )
+          end
+          def self.values
+          end
+        end
+      end
+
+      class ThreadStreamItemCompletedMessage < Cerca::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              Cerca::ThreadStreamEvent::ThreadStreamItemCompletedMessage,
+              Cerca::Internal::AnyHash
+            )
+          end
+
+        sig { returns(Float) }
+        attr_accessor :duration_ms
+
+        sig { returns(Float) }
+        attr_accessor :event_seq
+
+        sig { returns(String) }
+        attr_accessor :item_id
+
+        sig do
+          returns(
+            Cerca::ThreadStreamEvent::ThreadStreamItemCompletedMessage::ItemType::TaggedSymbol
+          )
+        end
+        attr_accessor :item_type
+
+        sig { returns(String) }
+        attr_accessor :turn_id
+
+        sig { returns(Symbol) }
+        attr_accessor :type
+
+        sig { returns(T.nilable(T::Boolean)) }
+        attr_reader :is_error
+
+        sig { params(is_error: T::Boolean).void }
+        attr_writer :is_error
+
+        sig { returns(T.nilable(String)) }
+        attr_reader :requested_tool_name
+
+        sig { params(requested_tool_name: String).void }
+        attr_writer :requested_tool_name
+
+        sig do
+          params(
+            duration_ms: Float,
+            event_seq: Float,
+            item_id: String,
+            item_type:
+              Cerca::ThreadStreamEvent::ThreadStreamItemCompletedMessage::ItemType::OrSymbol,
+            turn_id: String,
+            is_error: T::Boolean,
+            requested_tool_name: String,
+            type: Symbol
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          duration_ms:,
+          event_seq:,
+          item_id:,
+          item_type:,
+          turn_id:,
+          is_error: nil,
+          requested_tool_name: nil,
+          type: :"item/completed"
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              duration_ms: Float,
+              event_seq: Float,
+              item_id: String,
+              item_type:
+                Cerca::ThreadStreamEvent::ThreadStreamItemCompletedMessage::ItemType::TaggedSymbol,
+              turn_id: String,
+              type: Symbol,
+              is_error: T::Boolean,
+              requested_tool_name: String
+            }
+          )
+        end
+        def to_hash
+        end
+
+        module ItemType
+          extend Cerca::Internal::Type::Enum
+
+          TaggedSymbol =
+            T.type_alias do
+              T.all(
+                Symbol,
+                Cerca::ThreadStreamEvent::ThreadStreamItemCompletedMessage::ItemType
+              )
+            end
+          OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+          TOOL_CALL =
+            T.let(
+              :tool_call,
+              Cerca::ThreadStreamEvent::ThreadStreamItemCompletedMessage::ItemType::TaggedSymbol
+            )
+          AGENT_MESSAGE =
+            T.let(
+              :agent_message,
+              Cerca::ThreadStreamEvent::ThreadStreamItemCompletedMessage::ItemType::TaggedSymbol
+            )
+          LLM_CALL =
+            T.let(
+              :llm_call,
+              Cerca::ThreadStreamEvent::ThreadStreamItemCompletedMessage::ItemType::TaggedSymbol
+            )
+          SUB_THREAD =
+            T.let(
+              :sub_thread,
+              Cerca::ThreadStreamEvent::ThreadStreamItemCompletedMessage::ItemType::TaggedSymbol
+            )
+
+          sig do
+            override.returns(
+              T::Array[
+                Cerca::ThreadStreamEvent::ThreadStreamItemCompletedMessage::ItemType::TaggedSymbol
+              ]
+            )
+          end
+          def self.values
+          end
+        end
+      end
+
+      class ThreadStreamTokenUsageMessage < Cerca::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              Cerca::ThreadStreamEvent::ThreadStreamTokenUsageMessage,
+              Cerca::Internal::AnyHash
+            )
+          end
+
+        sig { returns(Float) }
+        attr_accessor :cumulative_input_tokens
+
+        sig { returns(Float) }
+        attr_accessor :cumulative_output_tokens
+
+        sig { returns(Float) }
+        attr_accessor :event_seq
+
+        sig { returns(Float) }
+        attr_accessor :input_tokens
+
+        sig { returns(Float) }
+        attr_accessor :output_tokens
+
+        sig { returns(String) }
+        attr_accessor :turn_id
+
+        sig { returns(Symbol) }
+        attr_accessor :type
+
+        sig do
+          params(
+            cumulative_input_tokens: Float,
+            cumulative_output_tokens: Float,
+            event_seq: Float,
+            input_tokens: Float,
+            output_tokens: Float,
+            turn_id: String,
+            type: Symbol
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          cumulative_input_tokens:,
+          cumulative_output_tokens:,
+          event_seq:,
+          input_tokens:,
+          output_tokens:,
+          turn_id:,
+          type: :token_usage
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              cumulative_input_tokens: Float,
+              cumulative_output_tokens: Float,
+              event_seq: Float,
+              input_tokens: Float,
+              output_tokens: Float,
+              turn_id: String,
+              type: Symbol
+            }
+          )
+        end
+        def to_hash
+        end
+      end
+
+      class ThreadStreamApprovalRequestedMessage < Cerca::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              Cerca::ThreadStreamEvent::ThreadStreamApprovalRequestedMessage,
+              Cerca::Internal::AnyHash
+            )
+          end
+
+        sig do
+          returns(
+            Cerca::ThreadStreamEvent::ThreadStreamApprovalRequestedMessage::Approval
+          )
+        end
+        attr_reader :approval
+
+        sig do
+          params(
+            approval:
+              Cerca::ThreadStreamEvent::ThreadStreamApprovalRequestedMessage::Approval::OrHash
+          ).void
+        end
+        attr_writer :approval
+
+        sig { returns(Float) }
+        attr_accessor :event_seq
+
+        sig { returns(String) }
+        attr_accessor :turn_id
+
+        sig { returns(Symbol) }
+        attr_accessor :type
+
+        sig do
+          params(
+            approval:
+              Cerca::ThreadStreamEvent::ThreadStreamApprovalRequestedMessage::Approval::OrHash,
+            event_seq: Float,
+            turn_id: String,
+            type: Symbol
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          approval:,
+          event_seq:,
+          turn_id:,
+          type: :"approval/requested"
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              approval:
+                Cerca::ThreadStreamEvent::ThreadStreamApprovalRequestedMessage::Approval,
+              event_seq: Float,
+              turn_id: String,
+              type: Symbol
+            }
+          )
+        end
+        def to_hash
+        end
+
+        class Approval < Cerca::Internal::Type::BaseModel
+          OrHash =
+            T.type_alias do
+              T.any(
+                Cerca::ThreadStreamEvent::ThreadStreamApprovalRequestedMessage::Approval,
+                Cerca::Internal::AnyHash
+              )
+            end
+
+          sig { returns(String) }
+          attr_accessor :id
+
+          sig { returns(String) }
+          attr_accessor :created_at
+
+          sig { returns(String) }
+          attr_accessor :requested_tool_name
+
+          sig { returns(T.nilable(String)) }
+          attr_accessor :resolved_at
+
+          sig do
+            returns(
+              Cerca::ThreadStreamEvent::ThreadStreamApprovalRequestedMessage::Approval::Status::TaggedSymbol
+            )
+          end
+          attr_accessor :status
+
+          sig { returns(String) }
+          attr_accessor :thread_id
+
+          sig { returns(T.nilable(String)) }
+          attr_accessor :timeout_at
+
+          sig { returns(T.nilable(Float)) }
+          attr_accessor :timeout_ms
+
+          sig { returns(Float) }
+          attr_accessor :tool_index
+
+          # JSON-serialized tool input payload. Parse as JSON before reading tool-specific
+          # fields.
+          sig { returns(String) }
+          attr_accessor :tool_input
+
+          sig { returns(Cerca::ToolName::TaggedSymbol) }
+          attr_accessor :tool_name
+
+          sig { returns(String) }
+          attr_accessor :tool_use_id
+
+          sig { returns(String) }
+          attr_accessor :turn_id
+
+          sig { returns(T.nilable(String)) }
+          attr_reader :tool_source_id
+
+          sig { params(tool_source_id: String).void }
+          attr_writer :tool_source_id
+
+          sig { returns(T.nilable(Float)) }
+          attr_reader :tool_source_version
+
+          sig { params(tool_source_version: Float).void }
+          attr_writer :tool_source_version
+
+          sig do
+            params(
+              id: String,
+              created_at: String,
+              requested_tool_name: String,
+              resolved_at: T.nilable(String),
+              status:
+                Cerca::ThreadStreamEvent::ThreadStreamApprovalRequestedMessage::Approval::Status::OrSymbol,
+              thread_id: String,
+              timeout_at: T.nilable(String),
+              timeout_ms: T.nilable(Float),
+              tool_index: Float,
+              tool_input: String,
+              tool_name: Cerca::ToolName::OrSymbol,
+              tool_use_id: String,
+              turn_id: String,
+              tool_source_id: String,
+              tool_source_version: Float
+            ).returns(T.attached_class)
+          end
+          def self.new(
+            id:,
+            created_at:,
+            requested_tool_name:,
+            resolved_at:,
+            status:,
+            thread_id:,
+            timeout_at:,
+            timeout_ms:,
+            tool_index:,
+            # JSON-serialized tool input payload. Parse as JSON before reading tool-specific
+            # fields.
+            tool_input:,
+            tool_name:,
+            tool_use_id:,
+            turn_id:,
+            tool_source_id: nil,
+            tool_source_version: nil
+          )
+          end
+
+          sig do
+            override.returns(
+              {
+                id: String,
+                created_at: String,
+                requested_tool_name: String,
+                resolved_at: T.nilable(String),
+                status:
+                  Cerca::ThreadStreamEvent::ThreadStreamApprovalRequestedMessage::Approval::Status::TaggedSymbol,
+                thread_id: String,
+                timeout_at: T.nilable(String),
+                timeout_ms: T.nilable(Float),
+                tool_index: Float,
+                tool_input: String,
+                tool_name: Cerca::ToolName::TaggedSymbol,
+                tool_use_id: String,
+                turn_id: String,
+                tool_source_id: String,
+                tool_source_version: Float
+              }
+            )
+          end
+          def to_hash
+          end
+
+          module Status
+            extend Cerca::Internal::Type::Enum
+
+            TaggedSymbol =
+              T.type_alias do
+                T.all(
+                  Symbol,
+                  Cerca::ThreadStreamEvent::ThreadStreamApprovalRequestedMessage::Approval::Status
+                )
+              end
+            OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+            PENDING =
+              T.let(
+                :pending,
+                Cerca::ThreadStreamEvent::ThreadStreamApprovalRequestedMessage::Approval::Status::TaggedSymbol
+              )
+            APPROVED =
+              T.let(
+                :approved,
+                Cerca::ThreadStreamEvent::ThreadStreamApprovalRequestedMessage::Approval::Status::TaggedSymbol
+              )
+            DENIED =
+              T.let(
+                :denied,
+                Cerca::ThreadStreamEvent::ThreadStreamApprovalRequestedMessage::Approval::Status::TaggedSymbol
+              )
+            CANCELLED =
+              T.let(
+                :cancelled,
+                Cerca::ThreadStreamEvent::ThreadStreamApprovalRequestedMessage::Approval::Status::TaggedSymbol
+              )
+            TIMED_OUT =
+              T.let(
+                :timed_out,
+                Cerca::ThreadStreamEvent::ThreadStreamApprovalRequestedMessage::Approval::Status::TaggedSymbol
+              )
+
+            sig do
+              override.returns(
+                T::Array[
+                  Cerca::ThreadStreamEvent::ThreadStreamApprovalRequestedMessage::Approval::Status::TaggedSymbol
+                ]
+              )
+            end
+            def self.values
+            end
+          end
+        end
+      end
+
+      class ThreadStreamApprovalResolvedMessage < Cerca::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              Cerca::ThreadStreamEvent::ThreadStreamApprovalResolvedMessage,
+              Cerca::Internal::AnyHash
+            )
+          end
+
+        sig { returns(String) }
+        attr_accessor :approval_id
+
+        sig do
+          returns(
+            Cerca::ThreadStreamEvent::ThreadStreamApprovalResolvedMessage::Decision::TaggedSymbol
+          )
+        end
+        attr_accessor :decision
+
+        sig { returns(Float) }
+        attr_accessor :event_seq
+
+        sig { returns(String) }
+        attr_accessor :turn_id
+
+        sig { returns(Symbol) }
+        attr_accessor :type
+
+        sig do
+          params(
+            approval_id: String,
+            decision:
+              Cerca::ThreadStreamEvent::ThreadStreamApprovalResolvedMessage::Decision::OrSymbol,
+            event_seq: Float,
+            turn_id: String,
+            type: Symbol
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          approval_id:,
+          decision:,
+          event_seq:,
+          turn_id:,
+          type: :"approval/resolved"
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              approval_id: String,
+              decision:
+                Cerca::ThreadStreamEvent::ThreadStreamApprovalResolvedMessage::Decision::TaggedSymbol,
+              event_seq: Float,
+              turn_id: String,
+              type: Symbol
+            }
+          )
+        end
+        def to_hash
+        end
+
+        module Decision
+          extend Cerca::Internal::Type::Enum
+
+          TaggedSymbol =
+            T.type_alias do
+              T.all(
+                Symbol,
+                Cerca::ThreadStreamEvent::ThreadStreamApprovalResolvedMessage::Decision
+              )
+            end
+          OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+          APPROVE =
+            T.let(
+              :approve,
+              Cerca::ThreadStreamEvent::ThreadStreamApprovalResolvedMessage::Decision::TaggedSymbol
+            )
+          DENY =
+            T.let(
+              :deny,
+              Cerca::ThreadStreamEvent::ThreadStreamApprovalResolvedMessage::Decision::TaggedSymbol
+            )
+          CANCEL =
+            T.let(
+              :cancel,
+              Cerca::ThreadStreamEvent::ThreadStreamApprovalResolvedMessage::Decision::TaggedSymbol
+            )
+          TIMEOUT =
+            T.let(
+              :timeout,
+              Cerca::ThreadStreamEvent::ThreadStreamApprovalResolvedMessage::Decision::TaggedSymbol
+            )
+
+          sig do
+            override.returns(
+              T::Array[
+                Cerca::ThreadStreamEvent::ThreadStreamApprovalResolvedMessage::Decision::TaggedSymbol
+              ]
+            )
+          end
+          def self.values
+          end
+        end
+      end
+
+      sig { override.returns(T::Array[Cerca::ThreadStreamEvent::Variants]) }
+      def self.variants
+      end
+    end
+  end
+end