Added Java SDK support to the AWS Lambda durable functions skill

plugins/aws-serverless/skills/aws-lambda-durable-functions/SKILL.md

@@ -24,6 +24,7 @@ Before using AWS Lambda durable functions, verify:
 2. **Runtime environment** is ready:
    - For TypeScript/JavaScript: Node.js 22+ (`node --version`)
    - For Python: Python 3.11+ (`python --version`. Note that currently only Lambda runtime environments 3.13+ come with the Durable Execution SDK pre-installed. 3.11 is the min supported Python version by the Durable SDK itself, however, you could use OCI to bring your own container image with your own Python runtime + Durable SDK.)
+   - For Java: Java 17+ (`java --version`)
 
 3. **Deployment capability** exists (one of):
    - AWS SAM CLI (`sam --version`) 1.153.1 or higher
@@ -40,6 +41,7 @@ Override syntax:
 
 - "use Python" → Generate Python code
 - "use JavaScript" → Generate JavaScript code
+- "use Java" → Generate Java code
 
 When not specified, ALWAYS use TypeScript
 
@@ -90,6 +92,28 @@ pip install aws-durable-execution-sdk-python
 pip install aws-durable-execution-sdk-python-testing
 ```
 
+**For Java (Maven):**
+
+```xml
+<properties>
+  <aws-durable-execution-sdk-java.version>LATEST</aws-durable-execution-sdk-java.version>
+</properties>
+
+<dependencies>
+  <dependency>
+    <groupId>software.amazon.lambda.durable</groupId>
+    <artifactId>aws-durable-execution-sdk-java</artifactId>
+    <version>${aws-durable-execution-sdk-java.version}</version>
+  </dependency>
+  <dependency>
+    <groupId>software.amazon.lambda.durable</groupId>
+    <artifactId>aws-durable-execution-sdk-java-testing</artifactId>
+    <version>${aws-durable-execution-sdk-java.version}</version>
+    <scope>test</scope>
+  </dependency>
+</dependencies>
+```
+
 ## When to Load Reference Files
 
 Load the appropriate reference file based on what the user is working on:
@@ -132,14 +156,31 @@ def handler(event: dict, context: DurableContext) -> dict:
     return result
 ```
 
+**Java:**
+
+```java
+import software.amazon.lambda.durable.DurableHandler;
+import software.amazon.lambda.durable.DurableContext;
+
+public class MyHandler extends DurableHandler<MyInput, MyOutput> {
+  @Override
+  public MyOutput handleRequest(MyInput event, DurableContext ctx) {
+    var result = ctx.step("process", ProcessResult.class, s -> processData(event));
+    return result;
+  }
+}
+```
+
 ### Critical Rules
 
 1. **All non-deterministic code MUST be in steps** (Date.now, Math.random, API calls)
 2. **Cannot nest durable operations** - use `runInChildContext` to group operations
 3. **Closure mutations are lost on replay** - return values from steps
 4. **Side effects outside steps repeat** - use `context.logger` (replay-aware)
 
-### Python API Differences
+### Language-Specific API Differences
+
+**Python:**
 
 The Python SDK differs from TypeScript in several key areas:
 
@@ -148,6 +189,17 @@ The Python SDK differs from TypeScript in several key areas:
 - **Exceptions**: `ExecutionError` (permanent), `InvocationError` (transient), `CallbackError` (callback failures)
 - **Testing**: Use `DurableFunctionTestRunner` class directly - instantiate with handler, use context manager, call `run(input=...)`
 
+**Java:**
+
+The Java SDK uses a class-based approach and type-safe patterns:
+
+- **Handler**: Extend `DurableHandler<TInput, TOutput>` and implement `handleRequest(TInput, DurableContext)`
+- **Steps**: `ctx.step("name", ResultType.class, stepCtx -> operation())` - type must be specified
+- **Wait**: `ctx.wait("name", Duration.ofSeconds(n))` - always name waits for debugging
+- **Generic Types**: Use `TypeToken` for generic types like `List<T>`: `ctx.step("name", new TypeToken<List<User>>() {}, stepCtx -> ...)`
+- **Exceptions**: `StepFailedException`, `StepInterruptedException`, `CallbackTimeoutException`, `CallbackFailedException`
+- **Testing**: Use `DurableFunctionTestRunner` class from testing SDK
+
 ### Invocation Requirements
 
 Durable functions **require qualified ARNs** (version, alias, or `$LATEST`):
@@ -201,4 +253,5 @@ Access to sensitive data (like Lambda and API Gateway logs) is **not** enabled b
 - [AWS Lambda durable functions Documentation](https://docs.aws.amazon.com/lambda/latest/dg/durable-functions.html)
 - [JavaScript SDK Repository](https://github.com/aws/aws-durable-execution-sdk-js)
 - [Python SDK Repository](https://github.com/aws/aws-durable-execution-sdk-python)
+- [Java SDK Repository](https://github.com/aws/aws-durable-execution-sdk-java)
 - [IAM Policy Reference](https://docs.aws.amazon.com/aws-managed-policy/latest/reference/AWSLambdaBasicDurableExecutionRolePolicy.html)

plugins/aws-serverless/skills/aws-lambda-durable-functions/references/advanced-error-handling.md

@@ -8,7 +8,7 @@ Advanced error handling patterns for durable functions, including timeout handli
 
 **Implementation approach:**
 
-1. Use `waitForCallback` (TypeScript) or `wait_for_callback` (Python) with a timeout configuration set in the config argument
+1. Use `waitForCallback` (TypeScript), `wait_for_callback` (Python), or `ctx.waitForCallback` (Java) with a timeout configuration set in the config argument
 2. Wrap in try-catch to handle timeout errors
 3. Check if the error is a timeout
 4. Implement fallback logic in a step (e.g., escalate to manager, use default value, retry with different parameters)
@@ -32,7 +32,10 @@ Advanced error handling patterns for durable functions, including timeout handli
 4. Execute fallback operation in a separate step
 
 **Important limitation:**
-In TypeScript, native setTimeout (and patterns like Promise.race using it) will fail during execution replays. To create a reliable timeout that persists across execution (expands over multi invocations), always use the timeout parameter provided by waitForCallback or waitForCondition
+In TypeScript, native setTimeout (and patterns like Promise.race using it) will fail during execution replays. To create a reliable timeout that persists across execution (expands over multi invocations), always use the timeout parameter provided by waitForCallback or waitForCondition.
+
+**Java considerations:**
+Java does not have an equivalent to Promise.race for local timeouts within a single invocation. Always use the timeout configuration in `CallbackConfig` or `WaitForConditionConfig` for reliable cross-invocation timeouts.
 
 ## Conditional Retry Based on Error Type
 
@@ -113,3 +116,9 @@ In TypeScript, native setTimeout (and patterns like Promise.race using it) will
 - Callback timeouts - external system didn't respond in time
 - External system delays - service is slow or unresponsive
 - Long-running operations - operation exceeded expected duration
+
+**Exception types by language:**
+
+- **TypeScript**: Timeout errors thrown from `waitForCallback` or `waitForCondition`
+- **Python**: `CallbackError` for callback failures
+- **Java**: `CallbackTimeoutException`, `CallbackFailedException`, `WaitForConditionFailedException`