temporal-spring-ai: per-model ActivityOptions registry

SpringAiPlugin now accepts an optional Map<String, ActivityOptions>
keyed by chat-model bean name. On construction the plugin publishes
the map to a new package-public static registry SpringAiPluginOptions,
which ActivityChatModel.forModel(name) and forDefault() consult when
building the activity stub. Entries resolve by bean name; the reserved
key SpringAiPlugin.DEFAULT_MODEL_NAME ("default") covers forDefault().

Callers who pass explicit ActivityOptions via forModel(name, options)
or forDefault(options) bypass the registry entirely — explicit options
always win. The registry has no effect on the (timeout, maxAttempts)
convenience factory either; that still builds options from its args.

Auto-configuration picks up a user bean named
"chatModelActivityOptions" (constant
SpringAiTemporalAutoConfiguration.CHAT_MODEL_ACTIVITY_OPTIONS_BEAN) of
type Map<String, ActivityOptions>. The explicit bean-name qualifier
avoids Spring's collection-of-beans auto-wiring for Map<String, T>.

Tests: PerModelActivityOptionsTest covers the three cases called out
in the plan — registry hit, registry miss (falls back to default
2-minute timeout), and explicit options bypass.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: donald-pinckney

temporal-spring-ai/src/main/java/io/temporal/springai/autoconfigure/SpringAiTemporalAutoConfiguration.java

@@ -1,10 +1,12 @@
 package io.temporal.springai.autoconfigure;
 
+import io.temporal.activity.ActivityOptions;
 import io.temporal.springai.plugin.SpringAiPlugin;
 import java.util.Map;
 import org.springframework.ai.chat.model.ChatModel;
 import org.springframework.beans.factory.ObjectProvider;
 import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.beans.factory.annotation.Qualifier;
 import org.springframework.boot.autoconfigure.AutoConfiguration;
 import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;
 import org.springframework.context.annotation.Bean;
@@ -28,9 +30,34 @@
     name = {"org.springframework.ai.chat.model.ChatModel", "io.temporal.worker.Worker"})
 public class SpringAiTemporalAutoConfiguration {
 
+  /** Bean name users declare their per-model {@link ActivityOptions} map under. */
+  public static final String CHAT_MODEL_ACTIVITY_OPTIONS_BEAN = "chatModelActivityOptions";
+
+  /**
+   * Builds the {@link SpringAiPlugin}. Picks up an optional user bean named {@value
+   * #CHAT_MODEL_ACTIVITY_OPTIONS_BEAN} of type {@code Map<String, ActivityOptions>} and forwards it
+   * as per-model overrides. The bean name is required (rather than auto-wiring by type) to avoid
+   * Spring's collection-of-beans autowiring behavior for {@code Map<String, ActivityOptions>}.
+   *
+   * <p>Example user config:
+   *
+   * <pre>{@code
+   * @Bean(SpringAiTemporalAutoConfiguration.CHAT_MODEL_ACTIVITY_OPTIONS_BEAN)
+   * public Map<String, ActivityOptions> chatModelActivityOptions() {
+   *     return Map.of(
+   *         "reasoning", ActivityOptions.newBuilder(ActivityChatModel.defaultActivityOptions())
+   *             .setStartToCloseTimeout(Duration.ofMinutes(15))
+   *             .build());
+   * }
+   * }</pre>
+   */
   @Bean
   public SpringAiPlugin springAiPlugin(
-      @Autowired Map<String, ChatModel> chatModels, ObjectProvider<ChatModel> primaryChatModel) {
-    return new SpringAiPlugin(chatModels, primaryChatModel.getIfUnique());
+      @Autowired Map<String, ChatModel> chatModels,
+      ObjectProvider<ChatModel> primaryChatModel,
+      @Qualifier(CHAT_MODEL_ACTIVITY_OPTIONS_BEAN)
+          ObjectProvider<Map<String, ActivityOptions>> perModelOptions) {
+    return new SpringAiPlugin(
+        chatModels, primaryChatModel.getIfUnique(), perModelOptions.getIfAvailable(Map::of));
   }
 }

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

@@ -3,6 +3,8 @@
 import io.temporal.activity.ActivityOptions;
 import io.temporal.common.RetryOptions;
 import io.temporal.springai.activity.ChatModelActivity;
+import io.temporal.springai.plugin.SpringAiPlugin;
+import io.temporal.springai.plugin.SpringAiPluginOptions;
 import io.temporal.workflow.Workflow;
 import java.net.URI;
 import java.net.URISyntaxException;
@@ -96,16 +98,29 @@ private ActivityChatModel(
   }
 
   /**
-   * Creates an ActivityChatModel for the default chat model with the plugin's default {@link
-   * ActivityOptions} (2-minute start-to-close timeout, 3 attempts, clearly permanent AI errors
-   * marked non-retryable).
+   * Creates an ActivityChatModel for the default chat model.
+   *
+   * <p>Options resolution order:
+   *
+   * <ol>
+   *   <li>An entry registered on {@link SpringAiPlugin} under {@link
+   *       SpringAiPlugin#DEFAULT_MODEL_NAME} in the per-model {@code ActivityOptions} map, if any.
+   *   <li>The plugin's default {@link ActivityOptions} (2-minute start-to-close, 3 attempts,
+   *       clearly permanent AI errors marked non-retryable).
+   * </ol>
+   *
+   * <p>Callers who want to set explicit options should use {@link #forDefault(ActivityOptions)} —
+   * explicit options bypass the registry entirely.
    *
    * <p><strong>Must be called from workflow code.</strong>
    *
    * @return an ActivityChatModel for the default chat model
    */
   public static ActivityChatModel forDefault() {
-    return forDefault(defaultActivityOptions(DEFAULT_TIMEOUT, DEFAULT_MAX_ATTEMPTS));
+    ActivityOptions options =
+        SpringAiPluginOptions.optionsFor(SpringAiPlugin.DEFAULT_MODEL_NAME)
+            .orElseGet(ActivityChatModel::defaultActivityOptions);
+    return forDefault(options);
   }
 
   /**
@@ -124,8 +139,19 @@ public static ActivityChatModel forDefault(ActivityOptions options) {
   }
 
   /**
-   * Creates an ActivityChatModel for a specific chat model by bean name with the plugin's default
-   * {@link ActivityOptions}.
+   * Creates an ActivityChatModel for a specific chat model by bean name.
+   *
+   * <p>Options resolution order:
+   *
+   * <ol>
+   *   <li>An entry registered on {@link SpringAiPlugin} under {@code modelName} in the per-model
+   *       {@code ActivityOptions} map, if any.
+   *   <li>The plugin's default {@link ActivityOptions} (2-minute start-to-close, 3 attempts,
+   *       clearly permanent AI errors marked non-retryable).
+   * </ol>
+   *
+   * <p>Callers who want to set explicit options should use {@link #forModel(String,
+   * ActivityOptions)} — explicit options bypass the registry entirely.
    *
    * <p><strong>Must be called from workflow code.</strong>
    *
@@ -134,7 +160,10 @@ public static ActivityChatModel forDefault(ActivityOptions options) {
    * @throws IllegalArgumentException if no model with that name exists (at activity runtime)
    */
   public static ActivityChatModel forModel(String modelName) {
-    return forModel(modelName, defaultActivityOptions(DEFAULT_TIMEOUT, DEFAULT_MAX_ATTEMPTS));
+    ActivityOptions options =
+        SpringAiPluginOptions.optionsFor(modelName)
+            .orElseGet(ActivityChatModel::defaultActivityOptions);
+    return forModel(modelName, options);
   }
 
   /**

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

@@ -1,5 +1,6 @@
 package io.temporal.springai.plugin;
 
+import io.temporal.activity.ActivityOptions;
 import io.temporal.common.SimplePlugin;
 import io.temporal.springai.activity.ChatModelActivityImpl;
 import io.temporal.worker.Worker;
@@ -55,9 +56,7 @@ public class SpringAiPlugin extends SimplePlugin {
    * @param chatModel the Spring AI chat model to wrap as an activity
    */
   public SpringAiPlugin(ChatModel chatModel) {
-    super("io.temporal.spring-ai");
-    this.chatModels = Map.of(DEFAULT_MODEL_NAME, chatModel);
-    this.defaultModelName = DEFAULT_MODEL_NAME;
+    this(Map.of(DEFAULT_MODEL_NAME, chatModel), null, Map.of());
   }
 
   /**
@@ -67,6 +66,25 @@ public SpringAiPlugin(ChatModel chatModel) {
    * @param primaryChatModel the primary chat model (used to determine default), or null
    */
   public SpringAiPlugin(Map<String, ChatModel> chatModels, @Nullable ChatModel primaryChatModel) {
+    this(chatModels, primaryChatModel, Map.of());
+  }
+
+  /**
+   * Creates a new SpringAiPlugin with multiple ChatModels and per-model {@link ActivityOptions}.
+   *
+   * <p>Entries in {@code perModelOptions} are keyed by chat-model bean name and consulted by {@link
+   * io.temporal.springai.model.ActivityChatModel#forModel(String)} (and by {@link
+   * io.temporal.springai.model.ActivityChatModel#forDefault()} via {@link #DEFAULT_MODEL_NAME}).
+   * Callers who pass explicit {@code ActivityOptions} to a factory bypass this map entirely.
+   *
+   * @param chatModels map of bean names to ChatModel instances
+   * @param primaryChatModel the primary chat model (used to determine default), or null
+   * @param perModelOptions per-model-name ActivityOptions overrides; may be empty
+   */
+  public SpringAiPlugin(
+      Map<String, ChatModel> chatModels,
+      @Nullable ChatModel primaryChatModel,
+      Map<String, ActivityOptions> perModelOptions) {
     super("io.temporal.spring-ai");
 
     if (chatModels == null || chatModels.isEmpty()) {
@@ -87,13 +105,21 @@ public SpringAiPlugin(Map<String, ChatModel> chatModels, @Nullable ChatModel pri
       this.defaultModelName = chatModels.keySet().iterator().next();
     }
 
+    SpringAiPluginOptions.register(perModelOptions);
+
     if (chatModels.size() > 1) {
       log.info(
           "Registered {} chat models: {} (default: {})",
           chatModels.size(),
           chatModels.keySet(),
           defaultModelName);
     }
+    if (perModelOptions != null && !perModelOptions.isEmpty()) {
+      log.info(
+          "Registered per-model ActivityOptions overrides for {} model(s): {}",
+          perModelOptions.size(),
+          perModelOptions.keySet());
+    }
   }
 
   @Override

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

@@ -0,0 +1,54 @@
+package io.temporal.springai.plugin;
+
+import io.temporal.activity.ActivityOptions;
+import java.util.Map;
+import java.util.Optional;
+import java.util.concurrent.atomic.AtomicReference;
+
+/**
+ * Process-scoped registry of per-chat-model {@link ActivityOptions}, populated by {@link
+ * SpringAiPlugin} at worker construction and consulted by {@link
+ * io.temporal.springai.model.ActivityChatModel#forModel(String)} when building the activity stub.
+ *
+ * <p>The registry is a static singleton because the plugin is a worker-side object but the lookup
+ * happens in workflow code that runs on the same JVM. Populating a shared static map before any
+ * workflow executes is the cleanest way to bridge that without teaching workflow code about plugin
+ * instances.
+ *
+ * <p>Limitations:
+ *
+ * <ul>
+ *   <li>Only one set of per-model options per JVM. Running multiple plugins in the same worker
+ *       process with different per-model options is not supported — the last registration wins.
+ *   <li>Callers who invoke {@link io.temporal.springai.model.ActivityChatModel#forModel(String,
+ *       ActivityOptions)} or {@link
+ *       io.temporal.springai.model.ActivityChatModel#forDefault(ActivityOptions)} bypass the
+ *       registry — explicit options always win.
+ * </ul>
+ */
+public final class SpringAiPluginOptions {
+
+  private static final AtomicReference<Map<String, ActivityOptions>> REGISTRY =
+      new AtomicReference<>(Map.of());
+
+  private SpringAiPluginOptions() {}
+
+  /**
+   * Installs the given per-model-name {@link ActivityOptions}, replacing any previous entries.
+   * Called by {@link SpringAiPlugin}. A null or empty map clears the registry.
+   */
+  public static void register(Map<String, ActivityOptions> options) {
+    REGISTRY.set(options == null || options.isEmpty() ? Map.of() : Map.copyOf(options));
+  }
+
+  /**
+   * Returns the options registered for the given model name, or empty if none. A null {@code
+   * modelName} always returns empty.
+   */
+  public static Optional<ActivityOptions> optionsFor(String modelName) {
+    if (modelName == null) {
+      return Optional.empty();
+    }
+    return Optional.ofNullable(REGISTRY.get().get(modelName));
+  }
+}