feat(interactions): add automaticContinuation to Interactions.CreateAsync in the .NET SDK

Foreground `Interactions.CreateAsync()` calls are capped per request by the server (32k output tokens unary, 64k streaming) and stop with `status="requires_continuation"` plus a `continuation_token`. `IInteractions.CreateAsync` and `Interactions.CreateAsync` now accept `bool? automaticContinuation = null` (default `true`) and `TimeSpan? timeout = null` and chain continuation hops client-side so a plain `CreateAsync()` returns the full decode.

Request chaining:
- Each hop after the first sends the `continuation_token` from the previous hop. With `Store` enabled (default) it sets `PreviousInteractionId` to the hop that issued the token and omits `Input`; with `Store = false` it resends the original `Input`.
- Unary foreground model calls default `GenerationConfig.MaxOutputTokens` to 65536 when unset without mutating caller request objects (streaming uses the server's 64k default). Explicit values are never overridden.
- Stops on `completed`, `incomplete` (token preserved for manual resumption), `requires_action`, `failed`, `cancelled`, a missing token, or a repeated token. Skipped for agent requests and `Background = true`; `Background = true` with `automaticContinuation: false` throws `ArgumentException`.

Unary (`Stream = false`) merging:
- Hops are merged into one `Interaction`: `Steps` concatenated in hop order (leading `user_input` steps dropped on later hops), `Usage` counts and per-modality breakdowns summed across hops with `Usage.InitialInputTokens` taken from hop 1, `Id` / `Status` / `ContinuationToken` / `Updated` from the final hop, and `PreviousInteractionId` / `Created` / `Input` from hop 1.
- `ContinuationIds` lists every hop id in order, de-duplicated with any server-provided ids. Convenience output properties (`OutputText`, etc.) are recomputed across hop boundaries.

Streaming (`Stream = true`):
- Events from all hops are yielded verbatim on `EventStream<InteractionSseEvent>` (`await foreach` and `Next()`). Consumers should treat `interaction.completed` with `status="requires_continuation"` as intermediate.
- Mid-hop transport drops or premature EOF resume from the latest `interaction.status_update` checkpoint token when no content was yielded since that checkpoint (up to 3 no-progress reconnects). SSE `error` events are terminal; HTTP status retries stay with `RetryConfig`.

Timeouts and errors:
- Per-call `TimeSpan? timeout` bounds the whole `CreateAsync()` call across hops via `CallDeadline`, while `HttpClient.Timeout`, `RetryConfig`, and `CancellationToken` apply per hop / immediate cancellation.
- A failure or timeout after progress throws `ContinuationInterruptedException` (`InnerException` set to the underlying error, or `ContinuationTimeoutException` on deadline expiry) carrying `PartialInteraction`, `ContinuationToken`, `InteractionId`, and `ContinuationIds` so billed work is preserved for manual resumption. First-hop failures propagate unchanged.

Opt-out:
- `automaticContinuation: false` returns the single server response untouched (no budget injection, no merging) and emits a one-time `Trace.TraceWarning` if it stops at `requires_continuation` without a caller-supplied `continuation_token`.

Tests: `Google.GenAI.Tests/InteractionsContinuationConformanceTest.cs` (52 conformance cases) and `Google.GenAI.Tests/InteractionsContinuationTest.cs` (whole-call timeout with fake clock, non-mutation, warning, and `EventStream.Next()` tests).
PiperOrigin-RevId: 995657094

Author: MarkDaoust

src/main/java/com/google/genai/gaos/AsyncInteractions.java

@@ -31,13 +31,11 @@
 import com.google.genai.gaos.models.operations.async.CancelInteractionByIdRequestBuilder;
 import com.google.genai.gaos.models.operations.async.CancelInteractionByIdResponse;
 import com.google.genai.gaos.models.operations.async.CreateInteractionRequestBuilder;
-import com.google.genai.gaos.models.operations.async.CreateInteractionResponse;
 import com.google.genai.gaos.models.operations.async.DeleteInteractionRequestBuilder;
 import com.google.genai.gaos.models.operations.async.DeleteInteractionResponse;
 import com.google.genai.gaos.models.operations.async.GetInteractionByIdRequestBuilder;
 import com.google.genai.gaos.models.operations.async.GetInteractionByIdResponse;
 import com.google.genai.gaos.operations.CancelInteractionById;
-import com.google.genai.gaos.operations.CreateInteraction;
 import com.google.genai.gaos.operations.DeleteInteraction;
 import com.google.genai.gaos.operations.GetInteractionById;
 import com.google.genai.gaos.operations.Operations;
@@ -91,6 +89,20 @@ public CompletableFuture<EventStream<InteractionSSEStreamEvent>> create(@Nonnull
         return create(null, body, null);
     }
 
+    /**
+     * Creates a new interaction.
+     * 
+     * @param body The request body.
+     * @param automaticContinuation Whether to automatically continue decoding across
+     *     continuation hops; see {@link #create(CreateInteractionRequest, Options)}.
+     * @return {@code CompletableFuture<EventStream<InteractionSSEStreamEvent>}&gt; - The async response
+     */
+    public CompletableFuture<EventStream<InteractionSSEStreamEvent>> create(
+            @Nonnull CreateInteractionRequestBody body, boolean automaticContinuation) {
+        return create(
+            new CreateInteractionRequest(null, body, automaticContinuation, null), null);
+    }
+
     /**
      * Creates a new interaction.
      * 
@@ -103,19 +115,42 @@ public CompletableFuture<EventStream<InteractionSSEStreamEvent>> create(@Nonnull
     public CompletableFuture<EventStream<InteractionSSEStreamEvent>> create(
             @Nullable String apiVersion, @Nonnull CreateInteractionRequestBody body,
             @Nullable Options options) {
-        CreateInteractionRequest request = new CreateInteractionRequest(apiVersion, body);
-        AsyncRequestOperation<CreateInteractionRequest, CreateInteractionResponse> operation
-              = new CreateInteraction.Async(
-                                    sdkConfiguration, options, sdkConfiguration.retryScheduler(),
-                                    _headers);
-        return Operations.relayCancel(Operations.applyBodyReadAsync(operation.doRequest(request),
-                operation::handleResponse)
-                .thenApplyAsync(response -> new EventStream<InteractionSSEStreamEvent>(
-                        response.rawResponse().body(),
-                        new TypeReference<InteractionSSEStreamEvent>() {
-                        },
-                        Utils.mapper(),
-                        Optional.of("[DONE]")), Operations.streamCompletionExecutor()), operation);
+        return create(new CreateInteractionRequest(apiVersion, body), options);
+    }
+
+    /**
+     * Creates a new interaction.
+     * 
+     * @param request The request object containing all the parameters for the API call.
+     * @return A CompletableFuture that completes with a blocking event stream once response headers are received.
+     * Iterating the stream blocks the calling thread; close it after use.
+     */
+    public CompletableFuture<EventStream<InteractionSSEStreamEvent>> create(
+            @Nonnull CreateInteractionRequest request) {
+        return create(request, null);
+    }
+
+    /**
+     * Creates a new interaction.
+     *
+     * <p>Automatic continuation ({@code request.automaticContinuation()}, default {@code true})
+     * works as described on {@link Interactions#create(CreateInteractionRequest, Options)}: with
+     * {@code stream=true}, the events of every continuation hop are yielded sequentially and
+     * verbatim on the returned stream, which fetches the next hop on the thread iterating it. A
+     * failure after progress ends the iteration with a
+     * {@link com.google.genai.gaos.models.errors.ContinuationInterruptedException} carrying the
+     * token to resume from. {@code background=true} with {@code automaticContinuation(false)} is
+     * rejected with an {@link IllegalArgumentException} before any request is sent.
+     * 
+     * @param request The request object containing all the parameters for the API call.
+     * @param options additional options
+     * @return A CompletableFuture that completes with a blocking event stream once response headers are received.
+     * Iterating the stream blocks the calling thread; close it after use.
+     */
+    public CompletableFuture<EventStream<InteractionSSEStreamEvent>> create(
+            @Nonnull CreateInteractionRequest request,
+            @Nullable Options options) {
+        return InteractionContinuation.createAsync(sdkConfiguration, request, options, _headers);
     }