feat: Added optional param to force empty object

Author: stainless-app[bot]

.stats.yml

@@ -1,4 +1,4 @@
 configured_endpoints: 7
-openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/browserbase%2Fstagehand-2c6c017cc9ca1fcfe7b3902edfa64fb0420bdb46b1740c7c862e81e2132d4f7c.yml
-openapi_spec_hash: 220daf7e8f5897909a6c10e3385386e3
+openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/browserbase%2Fstagehand-39cd9547d16412cf0568f6ce2ad8d43805dffe65bde830beeff630b903ae3b38.yml
+openapi_spec_hash: 9cd7c9fefa686f9711392782d948470f
 config_hash: 1f709f8775e13029dc60064ef3a94355

stagehand-java-core/src/main/kotlin/com/browserbase/api/models/sessions/SessionEndParams.kt

@@ -3,16 +3,21 @@
 package com.browserbase.api.models.sessions
 
 import com.browserbase.api.core.Enum
+import com.browserbase.api.core.ExcludeMissing
 import com.browserbase.api.core.JsonField
+import com.browserbase.api.core.JsonMissing
 import com.browserbase.api.core.JsonValue
 import com.browserbase.api.core.Params
-import com.browserbase.api.core.checkRequired
 import com.browserbase.api.core.http.Headers
 import com.browserbase.api.core.http.QueryParams
 import com.browserbase.api.errors.StagehandInvalidDataException
+import com.fasterxml.jackson.annotation.JsonAnyGetter
+import com.fasterxml.jackson.annotation.JsonAnySetter
 import com.fasterxml.jackson.annotation.JsonCreator
+import com.fasterxml.jackson.annotation.JsonProperty
 import java.time.OffsetDateTime
 import java.time.format.DateTimeFormatter
+import java.util.Collections
 import java.util.Objects
 import java.util.Optional
 import kotlin.jvm.optionals.getOrNull
@@ -25,7 +30,7 @@ private constructor(
     private val xSdkVersion: String?,
     private val xSentAt: OffsetDateTime?,
     private val xStreamResponse: XStreamResponse?,
-    private val body: JsonValue,
+    private val body: Body,
     private val additionalHeaders: Headers,
     private val additionalQueryParams: QueryParams,
 ) : Params {
@@ -45,7 +50,9 @@ private constructor(
     /** Whether to stream the response via SSE */
     fun xStreamResponse(): Optional<XStreamResponse> = Optional.ofNullable(xStreamResponse)
 
-    fun body(): JsonValue = body
+    fun __forceBody(): JsonValue = body.__forceBody()
+
+    fun _additionalBodyProperties(): Map<String, JsonValue> = body._additionalProperties()
 
     /** Additional headers to send with the request. */
     fun _additionalHeaders(): Headers = additionalHeaders
@@ -57,14 +64,9 @@ private constructor(
 
     companion object {
 
-        /**
-         * Returns a mutable builder for constructing an instance of [SessionEndParams].
-         *
-         * The following fields are required:
-         * ```java
-         * .body()
-         * ```
-         */
+        @JvmStatic fun none(): SessionEndParams = builder().build()
+
+        /** Returns a mutable builder for constructing an instance of [SessionEndParams]. */
         @JvmStatic fun builder() = Builder()
     }
 
@@ -76,7 +78,7 @@ private constructor(
         private var xSdkVersion: String? = null
         private var xSentAt: OffsetDateTime? = null
         private var xStreamResponse: XStreamResponse? = null
-        private var body: JsonValue? = null
+        private var body: Body.Builder = Body.builder()
         private var additionalHeaders: Headers.Builder = Headers.builder()
         private var additionalQueryParams: QueryParams.Builder = QueryParams.builder()
 
@@ -87,7 +89,7 @@ private constructor(
             xSdkVersion = sessionEndParams.xSdkVersion
             xSentAt = sessionEndParams.xSentAt
             xStreamResponse = sessionEndParams.xStreamResponse
-            body = sessionEndParams.body
+            body = sessionEndParams.body.toBuilder()
             additionalHeaders = sessionEndParams.additionalHeaders.toBuilder()
             additionalQueryParams = sessionEndParams.additionalQueryParams.toBuilder()
         }
@@ -125,7 +127,35 @@ private constructor(
         fun xStreamResponse(xStreamResponse: Optional<XStreamResponse>) =
             xStreamResponse(xStreamResponse.getOrNull())
 
-        fun body(body: JsonValue) = apply { this.body = body }
+        /**
+         * Sets the entire request body.
+         *
+         * This is generally only useful if you are already constructing the body separately.
+         * Otherwise, it's more convenient to use the top-level setters instead:
+         * - [_forceBody]
+         */
+        fun body(body: Body) = apply { this.body = body.toBuilder() }
+
+        fun _forceBody(_forceBody: JsonValue) = apply { body._forceBody(_forceBody) }
+
+        fun additionalBodyProperties(additionalBodyProperties: Map<String, JsonValue>) = apply {
+            body.additionalProperties(additionalBodyProperties)
+        }
+
+        fun putAdditionalBodyProperty(key: String, value: JsonValue) = apply {
+            body.putAdditionalProperty(key, value)
+        }
+
+        fun putAllAdditionalBodyProperties(additionalBodyProperties: Map<String, JsonValue>) =
+            apply {
+                body.putAllAdditionalProperties(additionalBodyProperties)
+            }
+
+        fun removeAdditionalBodyProperty(key: String) = apply { body.removeAdditionalProperty(key) }
+
+        fun removeAllAdditionalBodyProperties(keys: Set<String>) = apply {
+            body.removeAllAdditionalProperties(keys)
+        }
 
         fun additionalHeaders(additionalHeaders: Headers) = apply {
             this.additionalHeaders.clear()
@@ -229,13 +259,6 @@ private constructor(
          * Returns an immutable instance of [SessionEndParams].
          *
          * Further updates to this [Builder] will not mutate the returned instance.
-         *
-         * The following fields are required:
-         * ```java
-         * .body()
-         * ```
-         *
-         * @throws IllegalStateException if any required field is unset.
          */
         fun build(): SessionEndParams =
             SessionEndParams(
@@ -244,13 +267,13 @@ private constructor(
                 xSdkVersion,
                 xSentAt,
                 xStreamResponse,
-                checkRequired("body", body),
+                body.build(),
                 additionalHeaders.build(),
                 additionalQueryParams.build(),
             )
     }
 
-    fun _body(): JsonValue = body
+    fun _body(): Body = body
 
     fun _pathParam(index: Int): String =
         when (index) {
@@ -271,6 +294,123 @@ private constructor(
 
     override fun _queryParams(): QueryParams = additionalQueryParams
 
+    class Body
+    @JsonCreator(mode = JsonCreator.Mode.DISABLED)
+    private constructor(
+        private val _forceBody: JsonValue,
+        private val additionalProperties: MutableMap<String, JsonValue>,
+    ) {
+
+        @JsonCreator
+        private constructor(
+            @JsonProperty("_forceBody") @ExcludeMissing _forceBody: JsonValue = JsonMissing.of()
+        ) : this(_forceBody, mutableMapOf())
+
+        @JsonProperty("_forceBody") @ExcludeMissing fun __forceBody(): JsonValue = _forceBody
+
+        @JsonAnySetter
+        private fun putAdditionalProperty(key: String, value: JsonValue) {
+            additionalProperties.put(key, value)
+        }
+
+        @JsonAnyGetter
+        @ExcludeMissing
+        fun _additionalProperties(): Map<String, JsonValue> =
+            Collections.unmodifiableMap(additionalProperties)
+
+        fun toBuilder() = Builder().from(this)
+
+        companion object {
+
+            /** Returns a mutable builder for constructing an instance of [Body]. */
+            @JvmStatic fun builder() = Builder()
+        }
+
+        /** A builder for [Body]. */
+        class Builder internal constructor() {
+
+            private var _forceBody: JsonValue = JsonMissing.of()
+            private var additionalProperties: MutableMap<String, JsonValue> = mutableMapOf()
+
+            @JvmSynthetic
+            internal fun from(body: Body) = apply {
+                _forceBody = body._forceBody
+                additionalProperties = body.additionalProperties.toMutableMap()
+            }
+
+            fun _forceBody(_forceBody: JsonValue) = apply { this._forceBody = _forceBody }
+
+            fun additionalProperties(additionalProperties: Map<String, JsonValue>) = apply {
+                this.additionalProperties.clear()
+                putAllAdditionalProperties(additionalProperties)
+            }
+
+            fun putAdditionalProperty(key: String, value: JsonValue) = apply {
+                additionalProperties.put(key, value)
+            }
+
+            fun putAllAdditionalProperties(additionalProperties: Map<String, JsonValue>) = apply {
+                this.additionalProperties.putAll(additionalProperties)
+            }
+
+            fun removeAdditionalProperty(key: String) = apply { additionalProperties.remove(key) }
+
+            fun removeAllAdditionalProperties(keys: Set<String>) = apply {
+                keys.forEach(::removeAdditionalProperty)
+            }
+
+            /**
+             * Returns an immutable instance of [Body].
+             *
+             * Further updates to this [Builder] will not mutate the returned instance.
+             */
+            fun build(): Body = Body(_forceBody, additionalProperties.toMutableMap())
+        }
+
+        private var validated: Boolean = false
+
+        fun validate(): Body = apply {
+            if (validated) {
+                return@apply
+            }
+
+            validated = true
+        }
+
+        fun isValid(): Boolean =
+            try {
+                validate()
+                true
+            } catch (e: StagehandInvalidDataException) {
+                false
+            }
+
+        /**
+         * Returns a score indicating how many valid values are contained in this object
+         * recursively.
+         *
+         * Used for best match union deserialization.
+         */
+        @JvmSynthetic internal fun validity(): Int = 0
+
+        override fun equals(other: Any?): Boolean {
+            if (this === other) {
+                return true
+            }
+
+            return other is Body &&
+                _forceBody == other._forceBody &&
+                additionalProperties == other.additionalProperties
+        }
+
+        private val hashCode: Int by lazy { Objects.hash(_forceBody, additionalProperties) }
+
+        override fun hashCode(): Int = hashCode
+
+        override fun toString() =
+            "Body{_forceBody=$_forceBody, additionalProperties=$additionalProperties}"
+    }
+
     /** Client SDK language */
     class XLanguage @JsonCreator private constructor(private val value: JsonField<String>) : Enum {
 

stagehand-java-core/src/main/kotlin/com/browserbase/api/services/async/SessionServiceAsync.kt

@@ -89,27 +89,36 @@ interface SessionServiceAsync {
     ): AsyncStreamResponse<StreamEvent>
 
     /** Terminates the browser session and releases all associated resources. */
-    fun end(id: String, params: SessionEndParams): CompletableFuture<SessionEndResponse> =
-        end(id, params, RequestOptions.none())
+    fun end(id: String): CompletableFuture<SessionEndResponse> = end(id, SessionEndParams.none())
 
     /** @see end */
     fun end(
         id: String,
-        params: SessionEndParams,
+        params: SessionEndParams = SessionEndParams.none(),
         requestOptions: RequestOptions = RequestOptions.none(),
     ): CompletableFuture<SessionEndResponse> =
         end(params.toBuilder().id(id).build(), requestOptions)
 
     /** @see end */
-    fun end(params: SessionEndParams): CompletableFuture<SessionEndResponse> =
-        end(params, RequestOptions.none())
+    fun end(
+        id: String,
+        params: SessionEndParams = SessionEndParams.none(),
+    ): CompletableFuture<SessionEndResponse> = end(id, params, RequestOptions.none())
 
     /** @see end */
     fun end(
         params: SessionEndParams,
         requestOptions: RequestOptions = RequestOptions.none(),
     ): CompletableFuture<SessionEndResponse>
 
+    /** @see end */
+    fun end(params: SessionEndParams): CompletableFuture<SessionEndResponse> =
+        end(params, RequestOptions.none())
+
+    /** @see end */
+    fun end(id: String, requestOptions: RequestOptions): CompletableFuture<SessionEndResponse> =
+        end(id, SessionEndParams.none(), requestOptions)
+
     /** Runs an autonomous AI agent that can perform complex multi-step browser tasks. */
     fun execute(
         id: String,
@@ -421,29 +430,40 @@ interface SessionServiceAsync {
          * Returns a raw HTTP response for `post /v1/sessions/{id}/end`, but is otherwise the same
          * as [SessionServiceAsync.end].
          */
+        fun end(id: String): CompletableFuture<HttpResponseFor<SessionEndResponse>> =
+            end(id, SessionEndParams.none())
+
+        /** @see end */
         fun end(
             id: String,
-            params: SessionEndParams,
+            params: SessionEndParams = SessionEndParams.none(),
+            requestOptions: RequestOptions = RequestOptions.none(),
         ): CompletableFuture<HttpResponseFor<SessionEndResponse>> =
-            end(id, params, RequestOptions.none())
+            end(params.toBuilder().id(id).build(), requestOptions)
 
         /** @see end */
         fun end(
             id: String,
+            params: SessionEndParams = SessionEndParams.none(),
+        ): CompletableFuture<HttpResponseFor<SessionEndResponse>> =
+            end(id, params, RequestOptions.none())
+
+        /** @see end */
+        fun end(
             params: SessionEndParams,
             requestOptions: RequestOptions = RequestOptions.none(),
-        ): CompletableFuture<HttpResponseFor<SessionEndResponse>> =
-            end(params.toBuilder().id(id).build(), requestOptions)
+        ): CompletableFuture<HttpResponseFor<SessionEndResponse>>
 
         /** @see end */
         fun end(params: SessionEndParams): CompletableFuture<HttpResponseFor<SessionEndResponse>> =
             end(params, RequestOptions.none())
 
         /** @see end */
         fun end(
-            params: SessionEndParams,
-            requestOptions: RequestOptions = RequestOptions.none(),
-        ): CompletableFuture<HttpResponseFor<SessionEndResponse>>
+            id: String,
+            requestOptions: RequestOptions,
+        ): CompletableFuture<HttpResponseFor<SessionEndResponse>> =
+            end(id, SessionEndParams.none(), requestOptions)
 
         /**
          * Returns a raw HTTP response for `post /v1/sessions/{id}/agentExecute`, but is otherwise