Merge branch 'main' into feature/http-1.x

Author: landonxjames

.changelog/1758554358.md

@@ -0,0 +1,14 @@
+---
+applies_to:
+- client
+- aws-sdk-rust
+authors:
+- aajtodd
+references:
+- smithy-rs#4265
+- smithy-rs#4189
+breaking: false
+new_feature: false
+bug_fix: true
+---
+Adds new `with_test_defaults_v2()` for all clients supporting region configuration which applies `us-east-1` as default region if not set by user. This allows `aws-smithy-mocks` to work for non AWS SDK generated clients. Also clarify `test-util` feature requirement when using `aws-smithy-mocks`.

.changelog/1759416345.md

@@ -0,0 +1,12 @@
+---
+applies_to:
+- server
+authors:
+- rcoh
+references: ["smithy-rs#4344", "smithy-rs#4325"]
+breaking: false
+new_feature: false
+bug_fix: true
+---
+Fix bug where servers did not attempt to parse an `initial-request`. `initial-requests` may be sent by clients both when they would contain valid data
+and when they are empty.

.changelog/1760124260.md

@@ -0,0 +1,12 @@
+---
+applies_to:
+  - client
+authors:
+  - rcoh
+references: [ "smithy-rs#4346" ]
+breaking: false
+new_feature: false
+bug_fix: true
+---
+
+Fix bug where httpQueryParams were silently dropped when no other query parameters were modeled.

.changelog/1760126889.md

@@ -0,0 +1,15 @@
+---
+applies_to:
+- client
+- aws-sdk-rust
+authors:
+- rcoh
+references: ["smithy-rs#4352", "smithy-rs#4353"]
+breaking: false
+new_feature: false
+bug_fix: true
+---
+Update clients to allow `initial-response` events to be accepted on event streams, even when know modeled initial response exists.
+
+This is required for spec compliance, backwards compatibility, and compatibility with non-smithy-rs based servers that
+MAY unconditionally send `initial-response` messages.

.changelog/1760625617.md

@@ -0,0 +1,23 @@
+---
+applies_to:
+- server
+authors:
+- rcoh
+references: ["smithy-rs#4352", "smithy-rs#4345"]
+breaking: false
+new_feature: true
+bug_fix: true
+---
+Update smithy-rs servers to support sending `initial-response` events over event streams.
+
+Prior to this change, event streams that had initial responses were unsupported. This change also adds a new codegen setting, `alwaysSendEventStreamInitialResponse`.
+
+When this setting is set to `true`, the generated server will unconditionally send `initial-response` objects, even when empty. This is required for compatibility with smithy-java as well as a few other clients.
+
+This setting defaults to false currently because smithy-rs based clients do not currently support this behavior.
+
+```json
+"codegen": {
+  "alwaysSendEventStreamInitialResponse": true // default false
+}
+```

.changelog/1760625769.md

@@ -0,0 +1,13 @@
+---
+applies_to:
+  - client
+authors:
+  - arielby
+references: [ "smithy-rs#4349" ]
+breaking: false
+new_feature: true
+bug_fix: true
+---
+
+Make Hyper idle pool timeout configurable, and fix the bug where pool timeouts
+would not work if the client was built directly.

.changelog/1760632713.md

@@ -0,0 +1,14 @@
+---
+applies_to:
+  - client
+  - server
+authors:
+  - arielby
+references: []
+breaking: false
+new_feature: true
+bug_fix: false
+---
+
+Include the protocol name in `package.metadata.smithy.protocol` in `Cargo.toml`
+to allow easily figuring out which protocol was used to generate a crate.

.changelog/1760981645.md

@@ -0,0 +1,9 @@
+---
+applies_to: ["aws-sdk-rust"]
+authors: ["c-thiel"]
+references: ["aws-sdk-rust#1366"]
+breaking: false
+new_feature: true
+bug_fix: false
+---
+Add tags to `AssumeRoleProviderBuilder`

.changelog/changelog.md

@@ -10,6 +10,44 @@
 
 Protocol files: `codegen-{core,server}/.../protocols/`
 
+## Protocol Tests
+
+Protocol tests validate that generated code correctly implements Smithy protocols (like restJson1, awsJson1_1, etc.).
+
+### Adding Protocol Tests
+
+Protocol tests are defined in Smithy model files using `@httpRequestTests` and `@httpResponseTests` traits:
+
+```
+@http(uri: "/my-operation", method: "GET")
+@httpRequestTests([
+    {
+        id: "MyOperationRequest",
+        documentation: "Test description",
+        protocol: "aws.protocols#restJson1",
+        method: "GET",
+        uri: "/my-operation",
+        queryParams: ["param1=value1", "param2=value2"],
+        params: {
+            queryMap: {
+                "param1": "value1",
+                "param2": "value2"
+            }
+        },
+        appliesTo: "client",
+    }
+])
+operation MyOperation {
+   input: MyOperationInput,
+}
+```
+
+### Key Protocol Test Locations
+
+- **`codegen-core/common-test-models/rest-json-extras.smithy`** - restJson1 protocol tests
+- **`codegen-core/common-test-models/constraints.smithy`** - Constraint validation tests with restJson1
+- **`codegen-client-test/model/main.smithy`** - awsJson1_1 protocol tests
+
 ## preludeScope: Rust Prelude Types
 
 **Always use `preludeScope` for Rust prelude types:**
@@ -28,6 +66,7 @@ rustTemplate(
 ## RuntimeType and Dependencies
 
 `RuntimeType` objects contain:
+
 - **`path`**: Rust path (e.g., `"::mime::Mime"`)
 - **`dependency`**: `CargoDependency` or `InlineDependency`
 
@@ -49,6 +88,20 @@ val smithyTypes = RuntimeType.smithyTypes(runtimeConfig)
 ❌ Wrong: `rust("const MIME: ::mime::Mime = ::mime::APPLICATION_JSON;")`
 ✅ Correct: `rustTemplate("const MIME: #{Mime}::Mime = #{Mime}::APPLICATION_JSON;", "Mime" to RuntimeType.Mime)`
 
+### String Interpolation in Templates
+
+**For RuntimeTypes and complex objects**: Use `#{name}` syntax. NOTE: you do not need to use `#{name:W}`. This is now
+the default. You may see old code with this pattern.
+**For simple strings**: Use `$` with `.dq()` for double-quoted strings
+
+```kotlin
+// ❌ Wrong - causes "Invalid type provided to RustSymbolFormatter"
+rustTemplate("let content_type = \"#{content_type}\";", "content_type" to "application/json")
+
+// ✅ Correct - use $ interpolation for strings
+rustTemplate("let content_type = ${contentType.dq()};")
+```
+
 ## RuntimeType.forInlineFun: Lazy Generation
 
 Code is only generated if used. `forInlineFun` enables lazy generation:
@@ -64,22 +117,91 @@ val mimeType = RuntimeType.forInlineFun("APPLICATION_JSON", module) {
 
 ⚠️ **Footgun**: Name collisions mean only one implementation gets generated.
 
+## GitHub CLI Integration
+
+**View issues and PRs:**
+
+```bash
+gh issue view <number> --repo smithy-lang/smithy-rs
+gh pr view <number> --repo smithy-lang/smithy-rs
+gh pr diff <number> --repo smithy-lang/smithy-rs
+```
+
+**Add comments (use single quotes for complex markdown):**
+
+```bash
+gh issue comment <number> --repo smithy-lang/smithy-rs --body 'markdown content with `backticks` and special chars'
+```
+
+**Comment Guidelines:**
+- Always ask for confirmation before posting comments
+- Always start comments with `*Comment from Claude*` in italics
+
+**Run PR Bot and Canary workflows:**
+
+```bash
+# Get PR info first
+gh pr view <PR_NUMBER> --repo smithy-lang/smithy-rs --json headRefOid,number
+
+# Run PR Bot (generates codegen diff and doc preview)
+gh workflow run "Invoke PR Bot as Maintainer" --repo smithy-lang/smithy-rs \
+  -f pull_number=<PR_NUMBER> -f commit_sha=<HEAD_SHA>
+
+# Run Canary (tests SDK generation and integration)
+gh workflow run "Invoke Canary as Maintainer" --repo smithy-lang/smithy-rs \
+  -f pull_request_number=<PR_NUMBER> -f commit_sha=<HEAD_SHA>
+```
+
+## Investigation Patterns
+
+**Before implementing changes:**
+
+1. **Research existing work** - Check related PRs/issues first
+2. **Build and examine generated code** - `./gradlew codegen-server-test:assemble --quiet`
+3. **Generated code location** - `codegen-server-test/build/smithyprojections/codegen-server-test/`
+4. **Key generated files** - `src/protocol_serde/shape_*.rs`, `src/event_stream_serde.rs`
+5. **Look for patterns** - Client vs server codegen often mirrors each other
+6. **Identify minimal change** - Understand current behavior before modifying codegen
+
+**Single Protocol Development:**
+
+- When working on a single protocol, uncomment the filter line in `codegen-server-test/build.gradle.kts:111`
+- This speeds up builds by only generating code for the protocol you're working on
+
+**Client/Server Symmetry:**
+
+Client changes often show the pattern for server-side implementation
+
+**Configuration Debugging:**
+- Server codegen settings go under `"codegen"` not `"codegenConfig"` in smithy-build.json
+- When settings aren't working, check the generated smithy-build.json structure first
+- Settings placement matters - wrong nesting means settings are ignored silently
+- Always verify actual generated configuration matches expectations
+
+**Testing Configuration Settings:**
+- Create separate services with different settings to test configuration behavior
+- Use integration tests that verify actual generated code behavior, not just compilation
+- Test both enabled and disabled states to ensure the setting actually controls behavior
+
 ## Testing
 
 ### Integration Tests
+
 Test actual generated code, not just codegen logic:
 
 ```kotlin
 serverIntegrationTest(model) { codegenContext, rustCrate ->
     rustCrate.testModule {
         tokioTest("test_accept_header") {
-            rustTemplate("""
+            rustTemplate(
+                """
                 let request = ::http::Request::builder()
                     .header("Accept", "application/cbor")
                     .body(Body::empty()).unwrap();
                 let result = MyInput::from_request(request).await;
                 result.expect("should accept valid header");
-            """)
+            """
+            )
         }
     }
 }
@@ -88,12 +210,14 @@ serverIntegrationTest(model) { codegenContext, rustCrate ->
 ### Running Tests
 
 **Codegen tests:**
+
 ```bash
 ./gradlew test --tests "*MyTest*"
 ./gradlew codegen-server-test:assemble --quiet
 ```
 
 **Debug failing tests:**
+
 ```bash
 # Remove --quiet to see failure details
 ./gradlew :codegen-core:test --tests "*InlineDependencyTest*"
@@ -102,29 +226,37 @@ grep -A 5 "AssertionError\|Exception" codegen-core/build/reports/tests/test/clas
 ```
 
 **Runtime tests:**
+
 ```bash
 cd rust-runtime && cargo test --quiet -p aws-smithy-types
 ```
 
 **Protocol tests:**
+
 ```bash
 ./gradlew codegen-client-test:assemble --quiet
 cd codegen-client-test/build/smithyprojections/codegen-client-test/rest_xml_extras/rust-client-codegen
 cargo test --quiet
 ```
 
+**Note: Always use `--quiet` with cargo commands to reduce noise and focus on actual errors.**
+
 ## Viewing Generated Code
 
 Generated code appears in:
+
 ```
 codegen-server-test/build/smithyprojections/codegen-server-test/SERVICE_NAME/rust-server-codegen/
 ```
 
 Enable debug comments:
+
 ```kotlin
-serverIntegrationTest(model, IntegrationTestParams(
-    additionalSettings = ServerAdditionalSettings.builder()
-        .generateCodegenComments()  // Adds Kotlin source line comments
-        .toObjectNode()
-)) { /* test code */ }
+serverIntegrationTest(
+    model, IntegrationTestParams(
+        additionalSettings = ServerAdditionalSettings.builder()
+            .generateCodegenComments()  // Adds Kotlin source line comments
+            .toObjectNode()
+    )
+) { /* test code */ }
 ```