google-apis-workspaceevents_v1 0.18.0 → 0.20.0

data/lib/google/apis/workspaceevents_v1/classes.rb

@@ -22,6 +22,172 @@ module Google
   module Apis
     module WorkspaceeventsV1
       
+      # Artifacts are the container for task completed results. These are similar to
+      # Messages but are intended to be the product of a task, as opposed to point-to-
+      # point communication.
+      class Artifact
+        include Google::Apis::Core::Hashable
+      
+        # Unique identifier (e.g. UUID) for the artifact. It must be at least unique
+        # within a task.
+        # Corresponds to the JSON property `artifactId`
+        # @return [String]
+        attr_accessor :artifact_id
+      
+        # A human readable description of the artifact, optional.
+        # Corresponds to the JSON property `description`
+        # @return [String]
+        attr_accessor :description
+      
+        # The URIs of extensions that are present or contributed to this Artifact.
+        # Corresponds to the JSON property `extensions`
+        # @return [Array<String>]
+        attr_accessor :extensions
+      
+        # Optional metadata included with the artifact.
+        # Corresponds to the JSON property `metadata`
+        # @return [Hash<String,Object>]
+        attr_accessor :metadata
+      
+        # A human readable name for the artifact.
+        # Corresponds to the JSON property `name`
+        # @return [String]
+        attr_accessor :name
+      
+        # The content of the artifact.
+        # Corresponds to the JSON property `parts`
+        # @return [Array<Google::Apis::WorkspaceeventsV1::Part>]
+        attr_accessor :parts
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @artifact_id = args[:artifact_id] if args.key?(:artifact_id)
+          @description = args[:description] if args.key?(:description)
+          @extensions = args[:extensions] if args.key?(:extensions)
+          @metadata = args[:metadata] if args.key?(:metadata)
+          @name = args[:name] if args.key?(:name)
+          @parts = args[:parts] if args.key?(:parts)
+        end
+      end
+      
+      # Defines authentication details, used for push notifications.
+      class AuthenticationInfo
+        include Google::Apis::Core::Hashable
+      
+        # Optional credentials
+        # Corresponds to the JSON property `credentials`
+        # @return [String]
+        attr_accessor :credentials
+      
+        # Supported authentication schemes - e.g. Basic, Bearer, etc
+        # Corresponds to the JSON property `schemes`
+        # @return [Array<String>]
+        attr_accessor :schemes
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @credentials = args[:credentials] if args.key?(:credentials)
+          @schemes = args[:schemes] if args.key?(:schemes)
+        end
+      end
+      
+      # 
+      class CancelTaskRequest
+        include Google::Apis::Core::Hashable
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+        end
+      end
+      
+      # DataPart represents a structured blob. This is most commonly a JSON payload.
+      class DataPart
+        include Google::Apis::Core::Hashable
+      
+        # 
+        # Corresponds to the JSON property `data`
+        # @return [Hash<String,Object>]
+        attr_accessor :data
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @data = args[:data] if args.key?(:data)
+        end
+      end
+      
+      # A generic empty message that you can re-use to avoid defining duplicated empty
+      # messages in your APIs. A typical example is to use it as the request or the
+      # response type of an API method. For instance: service Foo ` rpc Bar(google.
+      # protobuf.Empty) returns (google.protobuf.Empty); `
+      class Empty
+        include Google::Apis::Core::Hashable
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+        end
+      end
+      
+      # FilePart represents the different ways files can be provided. If files are
+      # small, directly feeding the bytes is supported via file_with_bytes. If the
+      # file is large, the agent should read the content as appropriate directly from
+      # the file_with_uri source.
+      class FilePart
+        include Google::Apis::Core::Hashable
+      
+        # 
+        # Corresponds to the JSON property `fileWithBytes`
+        # NOTE: Values are automatically base64 encoded/decoded in the client library.
+        # @return [String]
+        attr_accessor :file_with_bytes
+      
+        # 
+        # Corresponds to the JSON property `fileWithUri`
+        # @return [String]
+        attr_accessor :file_with_uri
+      
+        # 
+        # Corresponds to the JSON property `mimeType`
+        # @return [String]
+        attr_accessor :mime_type
+      
+        # 
+        # Corresponds to the JSON property `name`
+        # @return [String]
+        attr_accessor :name
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @file_with_bytes = args[:file_with_bytes] if args.key?(:file_with_bytes)
+          @file_with_uri = args[:file_with_uri] if args.key?(:file_with_uri)
+          @mime_type = args[:mime_type] if args.key?(:mime_type)
+          @name = args[:name] if args.key?(:name)
+        end
+      end
+      
       # The response message for SubscriptionsService.ListSubscriptions.
       class ListSubscriptionsResponse
         include Google::Apis::Core::Hashable
@@ -48,6 +214,97 @@ module Google
         end
       end
       
+      # 
+      class ListTaskPushNotificationConfigResponse
+        include Google::Apis::Core::Hashable
+      
+        # The list of push notification configurations.
+        # Corresponds to the JSON property `configs`
+        # @return [Array<Google::Apis::WorkspaceeventsV1::TaskPushNotificationConfig>]
+        attr_accessor :configs
+      
+        # A token, which can be sent as `page_token` to retrieve the next page. If this
+        # field is omitted, there are no subsequent pages.
+        # Corresponds to the JSON property `nextPageToken`
+        # @return [String]
+        attr_accessor :next_page_token
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @configs = args[:configs] if args.key?(:configs)
+          @next_page_token = args[:next_page_token] if args.key?(:next_page_token)
+        end
+      end
+      
+      # Message is one unit of communication between client and server. It is
+      # associated with a context and optionally a task. Since the server is
+      # responsible for the context definition, it must always provide a context_id in
+      # its messages. The client can optionally provide the context_id if it knows the
+      # context to associate the message to. Similarly for task_id, except the server
+      # decides if a task is created and whether to include the task_id.
+      class Message
+        include Google::Apis::Core::Hashable
+      
+        # protolint:disable REPEATED_FIELD_NAMES_PLURALIZED Content is the container of
+        # the message content.
+        # Corresponds to the JSON property `content`
+        # @return [Array<Google::Apis::WorkspaceeventsV1::Part>]
+        attr_accessor :content
+      
+        # The context id of the message. This is optional and if set, the message will
+        # be associated with the given context.
+        # Corresponds to the JSON property `contextId`
+        # @return [String]
+        attr_accessor :context_id
+      
+        # The URIs of extensions that are present or contributed to this Message.
+        # Corresponds to the JSON property `extensions`
+        # @return [Array<String>]
+        attr_accessor :extensions
+      
+        # The unique identifier (e.g. UUID)of the message. This is required and created
+        # by the message creator.
+        # Corresponds to the JSON property `messageId`
+        # @return [String]
+        attr_accessor :message_id
+      
+        # protolint:enable REPEATED_FIELD_NAMES_PLURALIZED Any optional metadata to
+        # provide along with the message.
+        # Corresponds to the JSON property `metadata`
+        # @return [Hash<String,Object>]
+        attr_accessor :metadata
+      
+        # A role for the message.
+        # Corresponds to the JSON property `role`
+        # @return [String]
+        attr_accessor :role
+      
+        # The task id of the message. This is optional and if set, the message will be
+        # associated with the given task.
+        # Corresponds to the JSON property `taskId`
+        # @return [String]
+        attr_accessor :task_id
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @content = args[:content] if args.key?(:content)
+          @context_id = args[:context_id] if args.key?(:context_id)
+          @extensions = args[:extensions] if args.key?(:extensions)
+          @message_id = args[:message_id] if args.key?(:message_id)
+          @metadata = args[:metadata] if args.key?(:metadata)
+          @role = args[:role] if args.key?(:role)
+          @task_id = args[:task_id] if args.key?(:task_id)
+        end
+      end
+      
       # The endpoint where the subscription delivers events.
       class NotificationEndpoint
         include Google::Apis::Core::Hashable
@@ -139,6 +396,48 @@ module Google
         end
       end
       
+      # Part represents a container for a section of communication content. Parts can
+      # be purely textual, some sort of file (image, video, etc) or a structured data
+      # blob (i.e. JSON).
+      class Part
+        include Google::Apis::Core::Hashable
+      
+        # DataPart represents a structured blob. This is most commonly a JSON payload.
+        # Corresponds to the JSON property `data`
+        # @return [Google::Apis::WorkspaceeventsV1::DataPart]
+        attr_accessor :data
+      
+        # FilePart represents the different ways files can be provided. If files are
+        # small, directly feeding the bytes is supported via file_with_bytes. If the
+        # file is large, the agent should read the content as appropriate directly from
+        # the file_with_uri source.
+        # Corresponds to the JSON property `file`
+        # @return [Google::Apis::WorkspaceeventsV1::FilePart]
+        attr_accessor :file
+      
+        # Optional metadata associated with this part.
+        # Corresponds to the JSON property `metadata`
+        # @return [Hash<String,Object>]
+        attr_accessor :metadata
+      
+        # 
+        # Corresponds to the JSON property `text`
+        # @return [String]
+        attr_accessor :text
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @data = args[:data] if args.key?(:data)
+          @file = args[:file] if args.key?(:file)
+          @metadata = args[:metadata] if args.key?(:metadata)
+          @text = args[:text] if args.key?(:text)
+        end
+      end
+      
       # Options about what data to include in the event payload. Only supported for
       # Google Chat and Google Drive events.
       class PayloadOptions
@@ -175,6 +474,43 @@ module Google
         end
       end
       
+      # Configuration for setting up push notifications for task updates.
+      class PushNotificationConfig
+        include Google::Apis::Core::Hashable
+      
+        # Defines authentication details, used for push notifications.
+        # Corresponds to the JSON property `authentication`
+        # @return [Google::Apis::WorkspaceeventsV1::AuthenticationInfo]
+        attr_accessor :authentication
+      
+        # A unique identifier (e.g. UUID) for this push notification.
+        # Corresponds to the JSON property `id`
+        # @return [String]
+        attr_accessor :id
+      
+        # Token unique for this task/session
+        # Corresponds to the JSON property `token`
+        # @return [String]
+        attr_accessor :token
+      
+        # Url to send the notification too
+        # Corresponds to the JSON property `url`
+        # @return [String]
+        attr_accessor :url
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @authentication = args[:authentication] if args.key?(:authentication)
+          @id = args[:id] if args.key?(:id)
+          @token = args[:token] if args.key?(:token)
+          @url = args[:url] if args.key?(:url)
+        end
+      end
+      
       # The request message for SubscriptionsService.ReactivateSubscription.
       class ReactivateSubscriptionRequest
         include Google::Apis::Core::Hashable
@@ -188,6 +524,83 @@ module Google
         end
       end
       
+      # Configuration of a send message request.
+      class SendMessageConfiguration
+        include Google::Apis::Core::Hashable
+      
+        # The output modes that the agent is expected to respond with.
+        # Corresponds to the JSON property `acceptedOutputModes`
+        # @return [Array<String>]
+        attr_accessor :accepted_output_modes
+      
+        # If true, the message will be blocking until the task is completed. If false,
+        # the message will be non-blocking and the task will be returned immediately. It
+        # is the caller's responsibility to check for any task updates.
+        # Corresponds to the JSON property `blocking`
+        # @return [Boolean]
+        attr_accessor :blocking
+        alias_method :blocking?, :blocking
+      
+        # The maximum number of messages to include in the history. if 0, the history
+        # will be unlimited.
+        # Corresponds to the JSON property `historyLength`
+        # @return [Fixnum]
+        attr_accessor :history_length
+      
+        # Configuration for setting up push notifications for task updates.
+        # Corresponds to the JSON property `pushNotification`
+        # @return [Google::Apis::WorkspaceeventsV1::PushNotificationConfig]
+        attr_accessor :push_notification
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @accepted_output_modes = args[:accepted_output_modes] if args.key?(:accepted_output_modes)
+          @blocking = args[:blocking] if args.key?(:blocking)
+          @history_length = args[:history_length] if args.key?(:history_length)
+          @push_notification = args[:push_notification] if args.key?(:push_notification)
+        end
+      end
+      
+      # /////////// Request Messages ///////////
+      class SendMessageRequest
+        include Google::Apis::Core::Hashable
+      
+        # Configuration of a send message request.
+        # Corresponds to the JSON property `configuration`
+        # @return [Google::Apis::WorkspaceeventsV1::SendMessageConfiguration]
+        attr_accessor :configuration
+      
+        # Message is one unit of communication between client and server. It is
+        # associated with a context and optionally a task. Since the server is
+        # responsible for the context definition, it must always provide a context_id in
+        # its messages. The client can optionally provide the context_id if it knows the
+        # context to associate the message to. Similarly for task_id, except the server
+        # decides if a task is created and whether to include the task_id.
+        # Corresponds to the JSON property `message`
+        # @return [Google::Apis::WorkspaceeventsV1::Message]
+        attr_accessor :message
+      
+        # Optional metadata for the request.
+        # Corresponds to the JSON property `metadata`
+        # @return [Hash<String,Object>]
+        attr_accessor :metadata
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @configuration = args[:configuration] if args.key?(:configuration)
+          @message = args[:message] if args.key?(:message)
+          @metadata = args[:metadata] if args.key?(:metadata)
+        end
+      end
+      
       # The `Status` type defines a logical error model that is suitable for different
       # programming environments, including REST APIs and RPC APIs. It is used by [
       # gRPC](https://github.com/grpc). Each `Status` message contains three pieces of
@@ -227,6 +640,58 @@ module Google
         end
       end
       
+      # The stream response for a message. The stream should be one of the following
+      # sequences: If the response is a message, the stream should contain one, and
+      # only one, message and then close If the response is a task lifecycle, the
+      # first response should be a Task object followed by zero or more
+      # TaskStatusUpdateEvents and TaskArtifactUpdateEvents. The stream should
+      # complete when the Task if in an interrupted or terminal state. A stream that
+      # ends before these conditions are met are
+      class StreamResponse
+        include Google::Apis::Core::Hashable
+      
+        # TaskArtifactUpdateEvent represents a task delta where an artifact has been
+        # generated.
+        # Corresponds to the JSON property `artifactUpdate`
+        # @return [Google::Apis::WorkspaceeventsV1::TaskArtifactUpdateEvent]
+        attr_accessor :artifact_update
+      
+        # Message is one unit of communication between client and server. It is
+        # associated with a context and optionally a task. Since the server is
+        # responsible for the context definition, it must always provide a context_id in
+        # its messages. The client can optionally provide the context_id if it knows the
+        # context to associate the message to. Similarly for task_id, except the server
+        # decides if a task is created and whether to include the task_id.
+        # Corresponds to the JSON property `message`
+        # @return [Google::Apis::WorkspaceeventsV1::Message]
+        attr_accessor :message
+      
+        # TaskStatusUpdateEvent is a delta even on a task indicating that a task has
+        # changed.
+        # Corresponds to the JSON property `statusUpdate`
+        # @return [Google::Apis::WorkspaceeventsV1::TaskStatusUpdateEvent]
+        attr_accessor :status_update
+      
+        # Task is the core unit of action for A2A. It has a current status and when
+        # results are created for the task they are stored in the artifact. If there are
+        # multiple turns for a task, these are stored in history.
+        # Corresponds to the JSON property `task`
+        # @return [Google::Apis::WorkspaceeventsV1::Task]
+        attr_accessor :task
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @artifact_update = args[:artifact_update] if args.key?(:artifact_update)
+          @message = args[:message] if args.key?(:message)
+          @status_update = args[:status_update] if args.key?(:status_update)
+          @task = args[:task] if args.key?(:task)
+        end
+      end
+      
       # A subscription to receive events about a Google Workspace resource. To learn
       # more about subscriptions, see the [Google Workspace Events API overview](https:
       # //developers.google.com/workspace/events).
@@ -362,6 +827,222 @@ module Google
           @update_time = args[:update_time] if args.key?(:update_time)
         end
       end
+      
+      # Task is the core unit of action for A2A. It has a current status and when
+      # results are created for the task they are stored in the artifact. If there are
+      # multiple turns for a task, these are stored in history.
+      class Task
+        include Google::Apis::Core::Hashable
+      
+        # A set of output artifacts for a Task.
+        # Corresponds to the JSON property `artifacts`
+        # @return [Array<Google::Apis::WorkspaceeventsV1::Artifact>]
+        attr_accessor :artifacts
+      
+        # Unique identifier (e.g. UUID) for the contextual collection of interactions (
+        # tasks and messages). Created by the A2A server.
+        # Corresponds to the JSON property `contextId`
+        # @return [String]
+        attr_accessor :context_id
+      
+        # protolint:disable REPEATED_FIELD_NAMES_PLURALIZED The history of interactions
+        # from a task.
+        # Corresponds to the JSON property `history`
+        # @return [Array<Google::Apis::WorkspaceeventsV1::Message>]
+        attr_accessor :history
+      
+        # Unique identifier (e.g. UUID) for the task, generated by the server for a new
+        # task.
+        # Corresponds to the JSON property `id`
+        # @return [String]
+        attr_accessor :id
+      
+        # protolint:enable REPEATED_FIELD_NAMES_PLURALIZED A key/value object to store
+        # custom metadata about a task.
+        # Corresponds to the JSON property `metadata`
+        # @return [Hash<String,Object>]
+        attr_accessor :metadata
+      
+        # A container for the status of a task
+        # Corresponds to the JSON property `status`
+        # @return [Google::Apis::WorkspaceeventsV1::TaskStatus]
+        attr_accessor :status
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @artifacts = args[:artifacts] if args.key?(:artifacts)
+          @context_id = args[:context_id] if args.key?(:context_id)
+          @history = args[:history] if args.key?(:history)
+          @id = args[:id] if args.key?(:id)
+          @metadata = args[:metadata] if args.key?(:metadata)
+          @status = args[:status] if args.key?(:status)
+        end
+      end
+      
+      # TaskArtifactUpdateEvent represents a task delta where an artifact has been
+      # generated.
+      class TaskArtifactUpdateEvent
+        include Google::Apis::Core::Hashable
+      
+        # Whether this should be appended to a prior one produced
+        # Corresponds to the JSON property `append`
+        # @return [Boolean]
+        attr_accessor :append
+        alias_method :append?, :append
+      
+        # Artifacts are the container for task completed results. These are similar to
+        # Messages but are intended to be the product of a task, as opposed to point-to-
+        # point communication.
+        # Corresponds to the JSON property `artifact`
+        # @return [Google::Apis::WorkspaceeventsV1::Artifact]
+        attr_accessor :artifact
+      
+        # The id of the context that this task belongs too
+        # Corresponds to the JSON property `contextId`
+        # @return [String]
+        attr_accessor :context_id
+      
+        # Whether this represents the last part of an artifact
+        # Corresponds to the JSON property `lastChunk`
+        # @return [Boolean]
+        attr_accessor :last_chunk
+        alias_method :last_chunk?, :last_chunk
+      
+        # Optional metadata associated with the artifact update.
+        # Corresponds to the JSON property `metadata`
+        # @return [Hash<String,Object>]
+        attr_accessor :metadata
+      
+        # The id of the task for this artifact
+        # Corresponds to the JSON property `taskId`
+        # @return [String]
+        attr_accessor :task_id
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @append = args[:append] if args.key?(:append)
+          @artifact = args[:artifact] if args.key?(:artifact)
+          @context_id = args[:context_id] if args.key?(:context_id)
+          @last_chunk = args[:last_chunk] if args.key?(:last_chunk)
+          @metadata = args[:metadata] if args.key?(:metadata)
+          @task_id = args[:task_id] if args.key?(:task_id)
+        end
+      end
+      
+      # 
+      class TaskPushNotificationConfig
+        include Google::Apis::Core::Hashable
+      
+        # The resource name of the config. Format: tasks/`task_id`/
+        # pushNotificationConfigs/`config_id`
+        # Corresponds to the JSON property `name`
+        # @return [String]
+        attr_accessor :name
+      
+        # Configuration for setting up push notifications for task updates.
+        # Corresponds to the JSON property `pushNotificationConfig`
+        # @return [Google::Apis::WorkspaceeventsV1::PushNotificationConfig]
+        attr_accessor :push_notification_config
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @name = args[:name] if args.key?(:name)
+          @push_notification_config = args[:push_notification_config] if args.key?(:push_notification_config)
+        end
+      end
+      
+      # A container for the status of a task
+      class TaskStatus
+        include Google::Apis::Core::Hashable
+      
+        # Message is one unit of communication between client and server. It is
+        # associated with a context and optionally a task. Since the server is
+        # responsible for the context definition, it must always provide a context_id in
+        # its messages. The client can optionally provide the context_id if it knows the
+        # context to associate the message to. Similarly for task_id, except the server
+        # decides if a task is created and whether to include the task_id.
+        # Corresponds to the JSON property `message`
+        # @return [Google::Apis::WorkspaceeventsV1::Message]
+        attr_accessor :message
+      
+        # The current state of this task
+        # Corresponds to the JSON property `state`
+        # @return [String]
+        attr_accessor :state
+      
+        # Timestamp when the status was recorded. Example: "2023-10-27T10:00:00Z"
+        # Corresponds to the JSON property `timestamp`
+        # @return [String]
+        attr_accessor :timestamp
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @message = args[:message] if args.key?(:message)
+          @state = args[:state] if args.key?(:state)
+          @timestamp = args[:timestamp] if args.key?(:timestamp)
+        end
+      end
+      
+      # TaskStatusUpdateEvent is a delta even on a task indicating that a task has
+      # changed.
+      class TaskStatusUpdateEvent
+        include Google::Apis::Core::Hashable
+      
+        # The id of the context that the task belongs to
+        # Corresponds to the JSON property `contextId`
+        # @return [String]
+        attr_accessor :context_id
+      
+        # Whether this is the last status update expected for this task.
+        # Corresponds to the JSON property `final`
+        # @return [Boolean]
+        attr_accessor :final
+        alias_method :final?, :final
+      
+        # Optional metadata to associate with the task update.
+        # Corresponds to the JSON property `metadata`
+        # @return [Hash<String,Object>]
+        attr_accessor :metadata
+      
+        # A container for the status of a task
+        # Corresponds to the JSON property `status`
+        # @return [Google::Apis::WorkspaceeventsV1::TaskStatus]
+        attr_accessor :status
+      
+        # The id of the task that is changed
+        # Corresponds to the JSON property `taskId`
+        # @return [String]
+        attr_accessor :task_id
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @context_id = args[:context_id] if args.key?(:context_id)
+          @final = args[:final] if args.key?(:final)
+          @metadata = args[:metadata] if args.key?(:metadata)
+          @status = args[:status] if args.key?(:status)
+          @task_id = args[:task_id] if args.key?(:task_id)
+        end
+      end
     end
   end
 end