Merge remote-tracking branch 'origin/master' into spring-ai/per-model-timeouts

# Conflicts:
#	temporal-spring-ai/build.gradle
#	temporal-spring-ai/src/main/java/io/temporal/springai/model/ActivityChatModel.java

Author: donald-pinckney

temporal-spring-ai/README.md

@@ -114,6 +114,22 @@ public class MyTools {
 
 Auto-detected and executed as Nexus operations, similar to activity stubs.
 
+## Media in messages
+
+If you attach media (images, audio, etc.) to a `UserMessage` or an `AssistantMessage`, prefer passing it by URI rather than raw bytes:
+
+```java
+// Good — only the URL crosses the activity boundary.
+Media image = new Media(MimeTypeUtils.IMAGE_PNG, URI.create("https://cdn.example.com/pic.png"));
+
+// Works, but size-limited — see below.
+Media image = new Media(MimeTypeUtils.IMAGE_PNG, new ByteArrayResource(bytes));
+```
+
+Raw `byte[]` media gets serialized into every chat activity's input *and* result payload, which end up inside Temporal workflow history events. Server-side history events have a fixed 2 MiB size limit; to leave headroom for messages, tool definitions, and options, the plugin enforces a **1 MiB default cap** on inline media bytes and fails fast with an `IllegalArgumentException` pointing you at the URI alternative.
+
+Override the cap by setting the system property `io.temporal.springai.maxMediaBytes` before your worker starts (pass a positive integer; `0` disables the check). For anything larger than a small thumbnail, the URI route is the right answer — have an activity write the bytes to blob storage, then pass only the URL into the conversation.
+
 ## Optional Integrations
 
 Auto-configured when their dependencies are on the classpath:

temporal-spring-ai/build.gradle

@@ -46,6 +46,8 @@ dependencies {
     testImplementation "org.mockito:mockito-core:${mockitoVersion}"
     testImplementation 'org.springframework.boot:spring-boot-starter-test'
     testImplementation 'org.springframework.ai:spring-ai-rag'
+    // Needed only so McpPluginTest can mock/reference McpSyncClient directly.
+    testImplementation 'org.springframework.ai:spring-ai-mcp'
     // Needed only so tests can reference Spring AI's NonTransientAiException to
     // verify the plugin's default retry classification.
     testImplementation 'org.springframework.ai:spring-ai-retry'

temporal-spring-ai/src/main/java/io/temporal/springai/activity/ChatModelActivityImpl.java

@@ -239,6 +239,7 @@ private ChatModelTypes.MediaContent fromMedia(Media media) {
     if (media.getData() instanceof String uri) {
       return new ChatModelTypes.MediaContent(mimeType, uri);
     } else if (media.getData() instanceof byte[] data) {
+      ChatModelTypes.checkMediaSize(data);
       return new ChatModelTypes.MediaContent(mimeType, data);
     }
     throw new IllegalArgumentException(

temporal-spring-ai/src/main/java/io/temporal/springai/model/ActivityChatModel.java

@@ -15,6 +15,9 @@
 import javax.annotation.Nullable;
 import org.springframework.ai.chat.messages.*;
 import org.springframework.ai.chat.metadata.ChatResponseMetadata;
+import org.springframework.ai.chat.metadata.DefaultUsage;
+import org.springframework.ai.chat.metadata.RateLimit;
+import org.springframework.ai.chat.metadata.Usage;
 import org.springframework.ai.chat.model.ChatModel;
 import org.springframework.ai.chat.model.ChatResponse;
 import org.springframework.ai.chat.model.Generation;
@@ -401,6 +404,7 @@ private ChatModelTypes.MediaContent toMediaContent(Media media) {
     if (media.getData() instanceof String uri) {
       return new ChatModelTypes.MediaContent(mimeType, uri);
     } else if (media.getData() instanceof byte[] data) {
+      ChatModelTypes.checkMediaSize(data);
       return new ChatModelTypes.MediaContent(mimeType, data);
     }
     throw new IllegalArgumentException(
@@ -415,11 +419,70 @@ private ChatResponse toResponse(ChatModelTypes.ChatModelActivityOutput output) {
 
     var builder = ChatResponse.builder().generations(generations);
     if (output.metadata() != null) {
-      builder.metadata(ChatResponseMetadata.builder().model(output.metadata().model()).build());
+      builder.metadata(toResponseMetadata(output.metadata()));
     }
     return builder.build();
   }
 
+  private ChatResponseMetadata toResponseMetadata(
+      ChatModelTypes.ChatModelActivityOutput.ChatResponseMetadata md) {
+    ChatResponseMetadata.Builder b = ChatResponseMetadata.builder().model(md.model());
+    Usage usage = toUsage(md.usage());
+    if (usage != null) {
+      b.usage(usage);
+    }
+    RateLimit rateLimit = toRateLimit(md.rateLimit());
+    if (rateLimit != null) {
+      b.rateLimit(rateLimit);
+    }
+    return b.build();
+  }
+
+  private Usage toUsage(ChatModelTypes.ChatModelActivityOutput.ChatResponseMetadata.Usage u) {
+    if (u == null) {
+      return null;
+    }
+    return new DefaultUsage(u.promptTokens(), u.completionTokens(), u.totalTokens());
+  }
+
+  private RateLimit toRateLimit(
+      ChatModelTypes.ChatModelActivityOutput.ChatResponseMetadata.RateLimit r) {
+    if (r == null) {
+      return null;
+    }
+    return new RateLimit() {
+      @Override
+      public Long getRequestsLimit() {
+        return r.requestLimit();
+      }
+
+      @Override
+      public Long getRequestsRemaining() {
+        return r.requestRemaining();
+      }
+
+      @Override
+      public java.time.Duration getRequestsReset() {
+        return r.requestReset();
+      }
+
+      @Override
+      public Long getTokensLimit() {
+        return r.tokenLimit();
+      }
+
+      @Override
+      public Long getTokensRemaining() {
+        return r.tokenRemaining();
+      }
+
+      @Override
+      public java.time.Duration getTokensReset() {
+        return r.tokenReset();
+      }
+    };
+  }
+
   private AssistantMessage toAssistantMessage(ChatModelTypes.Message message) {
     List<AssistantMessage.ToolCall> toolCalls = List.of();
     if (!CollectionUtils.isEmpty(message.toolCalls())) {

temporal-spring-ai/src/main/java/io/temporal/springai/model/ChatModelTypes.java

@@ -4,6 +4,7 @@
 import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
 import com.fasterxml.jackson.annotation.JsonInclude;
 import com.fasterxml.jackson.annotation.JsonProperty;
+import io.temporal.failure.ApplicationFailure;
 import java.time.Duration;
 import java.util.List;
 import javax.annotation.Nullable;
@@ -16,6 +17,50 @@
  */
 public final class ChatModelTypes {
 
+  /**
+   * Maximum size, in bytes, of a single {@link MediaContent#data()} byte array carried across the
+   * chat activity boundary. Bytes above this threshold land inside workflow history events, which
+   * have a fixed 2 MiB per-event limit on the Temporal server. 1 MiB leaves headroom for the rest
+   * of a chat payload (messages, tool definitions, options).
+   *
+   * <p>Users who want to raise or lower the cap can set the system property {@code
+   * io.temporal.springai.maxMediaBytes} to a positive integer before the chat activity runs; values
+   * &lt;= 0 disable the guard entirely. For most workloads, pass media by URI instead — write the
+   * bytes to a binary store from an activity, and pass only the URL across the conversation.
+   */
+  public static final long MAX_MEDIA_BYTES_IN_HISTORY =
+      Long.getLong("io.temporal.springai.maxMediaBytes", 1L * 1024 * 1024);
+
+  /** Failure type on the {@link ApplicationFailure} thrown by {@link #checkMediaSize(byte[])}. */
+  public static final String MEDIA_SIZE_EXCEEDED_FAILURE_TYPE = "MediaSizeExceeded";
+
+  /**
+   * Throws a non-retryable {@link ApplicationFailure} if {@code data} exceeds {@link
+   * #MAX_MEDIA_BYTES_IN_HISTORY}. Non-retryable because this is a permanent, programmer-level error
+   * — retrying the same oversized payload will never succeed, and using a plain {@link
+   * RuntimeException} here would cause the workflow task to be retried forever (or the activity to
+   * churn through its {@code maxAttempts}) rather than surfacing the real problem. The failure
+   * message points the caller at the URI-based {@code Media} constructor. Pass-through otherwise.
+   */
+  public static void checkMediaSize(byte[] data) {
+    if (data == null) {
+      return;
+    }
+    long limit = MAX_MEDIA_BYTES_IN_HISTORY;
+    if (limit > 0 && data.length > limit) {
+      throw ApplicationFailure.newNonRetryableFailure(
+          "Media byte[] is "
+              + data.length
+              + " bytes, which exceeds the "
+              + limit
+              + "-byte limit for inline media in Temporal workflow history. Pass the media by "
+              + "URI instead: store the bytes outside the workflow (e.g. S3) and construct "
+              + "Media(mimeType, URI). Set the system property "
+              + "'io.temporal.springai.maxMediaBytes' to override this limit (or 0 to disable).",
+          MEDIA_SIZE_EXCEEDED_FAILURE_TYPE);
+    }
+  }
+
   private ChatModelTypes() {}
 
   /**

temporal-spring-ai/src/main/java/io/temporal/springai/plugin/McpPlugin.java

@@ -6,6 +6,7 @@
 import io.temporal.worker.Worker;
 import java.util.ArrayList;
 import java.util.List;
+import java.util.Map;
 import javax.annotation.Nonnull;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
@@ -39,22 +40,22 @@ public void setApplicationContext(ApplicationContext applicationContext) throws
     this.applicationContext = applicationContext;
   }
 
-  @SuppressWarnings("unchecked")
   private List<McpSyncClient> getMcpClients() {
     if (!mcpClients.isEmpty()) {
       return mcpClients;
     }
+    if (applicationContext == null) {
+      return mcpClients;
+    }
 
-    if (applicationContext != null && applicationContext.containsBean("mcpSyncClients")) {
-      try {
-        Object bean = applicationContext.getBean("mcpSyncClients");
-        if (bean instanceof List<?> clientList && !clientList.isEmpty()) {
-          mcpClients = (List<McpSyncClient>) clientList;
-          log.info("Found {} MCP client(s) in ApplicationContext", mcpClients.size());
-        }
-      } catch (Exception e) {
-        log.debug("Failed to get mcpSyncClients bean: {}", e.getMessage());
+    try {
+      Map<String, McpSyncClient> beans = applicationContext.getBeansOfType(McpSyncClient.class);
+      if (!beans.isEmpty()) {
+        mcpClients = List.copyOf(beans.values());
+        log.info("Discovered {} MCP client bean(s): {}", beans.size(), beans.keySet());
       }
+    } catch (Exception e) {
+      log.debug("Failed to look up McpSyncClient beans: {}", e.getMessage());
     }
 
     return mcpClients;