Split SpringAiPlugin into conditional auto-configuration (T6)

Split the monolithic SpringAiPlugin into one core plugin + three
optional plugins, each with its own @ConditionalOnClass-guarded
auto-configuration:

- SpringAiPlugin: core chat + ExecuteToolLocalActivity (always)
- VectorStorePlugin: VectorStore activity (when spring-ai-rag present)
- EmbeddingModelPlugin: EmbeddingModel activity (when spring-ai-rag present)
- McpPlugin: MCP activity (when spring-ai-mcp present)

This fixes ClassNotFoundException when optional deps aren't on the
runtime classpath. compileOnly scopes now work correctly because
Spring skips loading the conditional classes entirely when the
@ConditionalOnClass check fails.

Also resolves T10 (unnecessary MCP reflection) — McpPlugin directly
references McpClientActivityImpl instead of using Class.forName().

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

Author: donald-pinckney

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

@@ -0,0 +1,25 @@
+package io.temporal.springai.autoconfigure;
+
+import io.temporal.springai.plugin.EmbeddingModelPlugin;
+import org.springframework.ai.embedding.EmbeddingModel;
+import org.springframework.boot.autoconfigure.AutoConfiguration;
+import org.springframework.boot.autoconfigure.condition.ConditionalOnBean;
+import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;
+import org.springframework.context.annotation.Bean;
+
+/**
+ * Auto-configuration for EmbeddingModel integration with Temporal.
+ *
+ * <p>Conditionally creates an {@link EmbeddingModelPlugin} when {@code spring-ai-rag} is on the
+ * classpath and an {@link EmbeddingModel} bean is available.
+ */
+@AutoConfiguration(after = SpringAiTemporalAutoConfiguration.class)
+@ConditionalOnClass(name = "org.springframework.ai.embedding.EmbeddingModel")
+@ConditionalOnBean(EmbeddingModel.class)
+public class SpringAiEmbeddingAutoConfiguration {
+
+  @Bean
+  public EmbeddingModelPlugin embeddingModelPlugin(EmbeddingModel embeddingModel) {
+    return new EmbeddingModelPlugin(embeddingModel);
+  }
+}

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

@@ -0,0 +1,22 @@
+package io.temporal.springai.autoconfigure;
+
+import io.temporal.springai.plugin.McpPlugin;
+import org.springframework.boot.autoconfigure.AutoConfiguration;
+import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;
+import org.springframework.context.annotation.Bean;
+
+/**
+ * Auto-configuration for MCP (Model Context Protocol) integration with Temporal.
+ *
+ * <p>Conditionally creates a {@link McpPlugin} when {@code spring-ai-mcp} and the MCP client
+ * library are on the classpath.
+ */
+@AutoConfiguration(after = SpringAiTemporalAutoConfiguration.class)
+@ConditionalOnClass(name = "io.modelcontextprotocol.client.McpSyncClient")
+public class SpringAiMcpAutoConfiguration {
+
+  @Bean
+  public McpPlugin mcpPlugin() {
+    return new McpPlugin();
+  }
+}

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

@@ -1,18 +1,38 @@
 package io.temporal.springai.autoconfigure;
 
 import io.temporal.springai.plugin.SpringAiPlugin;
+import java.util.Map;
+import org.springframework.ai.chat.model.ChatModel;
+import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.boot.autoconfigure.AutoConfiguration;
 import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;
-import org.springframework.context.annotation.Import;
+import org.springframework.context.annotation.Bean;
+import org.springframework.lang.Nullable;
 
 /**
- * Auto-configuration for the Spring AI Temporal plugin.
+ * Core auto-configuration for the Spring AI Temporal plugin.
  *
- * <p>Automatically registers {@link SpringAiPlugin} as a bean when Spring AI and Temporal SDK are
- * on the classpath. The plugin then auto-registers Spring AI activities with all Temporal workers.
+ * <p>Creates the {@link SpringAiPlugin} bean which registers {@link
+ * io.temporal.springai.activity.ChatModelActivity} and {@link
+ * io.temporal.springai.tool.ExecuteToolLocalActivity} with all Temporal workers.
+ *
+ * <p>Optional integrations are handled by separate auto-configuration classes:
+ *
+ * <ul>
+ *   <li>{@link SpringAiVectorStoreAutoConfiguration} - VectorStore support
+ *   <li>{@link SpringAiEmbeddingAutoConfiguration} - EmbeddingModel support
+ *   <li>{@link SpringAiMcpAutoConfiguration} - MCP support
+ * </ul>
  */
 @AutoConfiguration
 @ConditionalOnClass(
     name = {"org.springframework.ai.chat.model.ChatModel", "io.temporal.worker.Worker"})
-@Import(SpringAiPlugin.class)
-public class SpringAiTemporalAutoConfiguration {}
+public class SpringAiTemporalAutoConfiguration {
+
+  @Bean
+  public SpringAiPlugin springAiPlugin(
+      @Autowired Map<String, ChatModel> chatModels,
+      @Autowired(required = false) @Nullable ChatModel primaryChatModel) {
+    return new SpringAiPlugin(chatModels, primaryChatModel);
+  }
+}

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

@@ -0,0 +1,25 @@
+package io.temporal.springai.autoconfigure;
+
+import io.temporal.springai.plugin.VectorStorePlugin;
+import org.springframework.ai.vectorstore.VectorStore;
+import org.springframework.boot.autoconfigure.AutoConfiguration;
+import org.springframework.boot.autoconfigure.condition.ConditionalOnBean;
+import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;
+import org.springframework.context.annotation.Bean;
+
+/**
+ * Auto-configuration for VectorStore integration with Temporal.
+ *
+ * <p>Conditionally creates a {@link VectorStorePlugin} when {@code spring-ai-rag} is on the
+ * classpath and a {@link VectorStore} bean is available.
+ */
+@AutoConfiguration(after = SpringAiTemporalAutoConfiguration.class)
+@ConditionalOnClass(name = "org.springframework.ai.vectorstore.VectorStore")
+@ConditionalOnBean(VectorStore.class)
+public class SpringAiVectorStoreAutoConfiguration {
+
+  @Bean
+  public VectorStorePlugin vectorStorePlugin(VectorStore vectorStore) {
+    return new VectorStorePlugin(vectorStore);
+  }
+}

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

@@ -0,0 +1,34 @@
+package io.temporal.springai.plugin;
+
+import io.temporal.common.SimplePlugin;
+import io.temporal.springai.activity.EmbeddingModelActivityImpl;
+import io.temporal.worker.Worker;
+import javax.annotation.Nonnull;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.ai.embedding.EmbeddingModel;
+
+/**
+ * Temporal plugin that registers {@link io.temporal.springai.activity.EmbeddingModelActivity} with
+ * workers.
+ *
+ * <p>This plugin is conditionally created by auto-configuration when Spring AI's {@link
+ * EmbeddingModel} is on the classpath and an EmbeddingModel bean is available.
+ */
+public class EmbeddingModelPlugin extends SimplePlugin {
+
+  private static final Logger log = LoggerFactory.getLogger(EmbeddingModelPlugin.class);
+
+  private final EmbeddingModel embeddingModel;
+
+  public EmbeddingModelPlugin(EmbeddingModel embeddingModel) {
+    super("io.temporal.spring-ai-embedding");
+    this.embeddingModel = embeddingModel;
+  }
+
+  @Override
+  public void initializeWorker(@Nonnull String taskQueue, @Nonnull Worker worker) {
+    worker.registerActivitiesImplementations(new EmbeddingModelActivityImpl(embeddingModel));
+    log.info("Registered EmbeddingModelActivity for task queue {}", taskQueue);
+  }
+}

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

@@ -0,0 +1,95 @@
+package io.temporal.springai.plugin;
+
+import io.modelcontextprotocol.client.McpSyncClient;
+import io.temporal.common.SimplePlugin;
+import io.temporal.springai.mcp.McpClientActivityImpl;
+import io.temporal.worker.Worker;
+import java.util.ArrayList;
+import java.util.List;
+import javax.annotation.Nonnull;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.BeansException;
+import org.springframework.beans.factory.SmartInitializingSingleton;
+import org.springframework.context.ApplicationContext;
+import org.springframework.context.ApplicationContextAware;
+
+/**
+ * Temporal plugin that registers {@link io.temporal.springai.mcp.McpClientActivity} with workers.
+ *
+ * <p>This plugin is conditionally created by auto-configuration when MCP classes are on the
+ * classpath. MCP clients may be created late by Spring AI's auto-configuration, so this plugin
+ * supports deferred registration via {@link SmartInitializingSingleton}.
+ */
+public class McpPlugin extends SimplePlugin
+    implements ApplicationContextAware, SmartInitializingSingleton {
+
+  private static final Logger log = LoggerFactory.getLogger(McpPlugin.class);
+
+  private List<McpSyncClient> mcpClients = List.of();
+  private ApplicationContext applicationContext;
+  private final List<Worker> pendingWorkers = new ArrayList<>();
+
+  public McpPlugin() {
+    super("io.temporal.spring-ai-mcp");
+  }
+
+  @Override
+  public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
+    this.applicationContext = applicationContext;
+  }
+
+  @SuppressWarnings("unchecked")
+  private List<McpSyncClient> getMcpClients() {
+    if (!mcpClients.isEmpty()) {
+      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());
+      }
+    }
+
+    return mcpClients;
+  }
+
+  @Override
+  public void initializeWorker(@Nonnull String taskQueue, @Nonnull Worker worker) {
+    List<McpSyncClient> clients = getMcpClients();
+    if (!clients.isEmpty()) {
+      worker.registerActivitiesImplementations(new McpClientActivityImpl(clients));
+      log.info(
+          "Registered McpClientActivity ({} clients) for task queue {}", clients.size(), taskQueue);
+    } else {
+      pendingWorkers.add(worker);
+      log.debug("MCP clients not yet available; will attempt registration after initialization");
+    }
+  }
+
+  @Override
+  public void afterSingletonsInstantiated() {
+    if (pendingWorkers.isEmpty()) {
+      return;
+    }
+
+    List<McpSyncClient> clients = getMcpClients();
+    if (clients.isEmpty()) {
+      log.debug("No MCP clients found after all beans initialized");
+      pendingWorkers.clear();
+      return;
+    }
+
+    for (Worker worker : pendingWorkers) {
+      worker.registerActivitiesImplementations(new McpClientActivityImpl(clients));
+      log.info("Registered deferred McpClientActivity ({} clients)", clients.size());
+    }
+    pendingWorkers.clear();
+  }
+}