temporal-spring-ai: attach activity summaries for chat and MCP calls

ActivityChatModel.forModel() now stores the ActivityOptions it built and,
on each chat call, rebuilds the stub with a per-call Summary of the form
"chat: <model> · <first 60 chars of user prompt>". When a caller passes a
pre-built stub directly via the public constructors, behavior is unchanged
(no options known → no summary overlay).

ActivityMcpClient.create() does the same and adds a callTool(clientName,
request, summary) overload. McpToolCallback passes "mcp: <client>.<tool>".

Also fixes the activity-type-name casing in ActivitySummaryTest — Temporal
capitalizes the first character of method-name-derived activity types, so
the event carries "CallChatModel", not "callChatModel".

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

Author: donald-pinckney

temporal-spring-ai/src/main/java/io/temporal/springai/mcp/ActivityMcpClient.java

@@ -48,6 +48,7 @@ public class ActivityMcpClient {
   public static final int DEFAULT_MAX_ATTEMPTS = 3;
 
   private final McpClientActivity activity;
+  private final ActivityOptions baseOptions;
   private Map<String, McpSchema.ServerCapabilities> serverCapabilities;
   private Map<String, McpSchema.Implementation> clientInfo;
 
@@ -57,7 +58,17 @@ public class ActivityMcpClient {
    * @param activity the activity stub for MCP operations
    */
   public ActivityMcpClient(McpClientActivity activity) {
+    this(activity, null);
+  }
+
+  /**
+   * Creates a new ActivityMcpClient. When {@code baseOptions} is non-null, {@link #callTool(String,
+   * McpSchema.CallToolRequest, String)} rebuilds the activity stub with a per-call Summary on top
+   * of those options.
+   */
+  private ActivityMcpClient(McpClientActivity activity, ActivityOptions baseOptions) {
     this.activity = activity;
+    this.baseOptions = baseOptions;
   }
 
   /**
@@ -81,14 +92,13 @@ public static ActivityMcpClient create() {
    * @return a new ActivityMcpClient
    */
   public static ActivityMcpClient create(Duration timeout, int maxAttempts) {
-    McpClientActivity activity =
-        Workflow.newActivityStub(
-            McpClientActivity.class,
-            ActivityOptions.newBuilder()
-                .setStartToCloseTimeout(timeout)
-                .setRetryOptions(RetryOptions.newBuilder().setMaximumAttempts(maxAttempts).build())
-                .build());
-    return new ActivityMcpClient(activity);
+    ActivityOptions options =
+        ActivityOptions.newBuilder()
+            .setStartToCloseTimeout(timeout)
+            .setRetryOptions(RetryOptions.newBuilder().setMaximumAttempts(maxAttempts).build())
+            .build();
+    McpClientActivity activity = Workflow.newActivityStub(McpClientActivity.class, options);
+    return new ActivityMcpClient(activity, options);
   }
 
   /**
@@ -127,7 +137,30 @@ public Map<String, McpSchema.Implementation> getClientInfo() {
    * @return the tool call result
    */
   public McpSchema.CallToolResult callTool(String clientName, McpSchema.CallToolRequest request) {
-    return activity.callTool(clientName, request);
+    return callTool(clientName, request, null);
+  }
+
+  /**
+   * Calls a tool on a specific MCP client, attaching the given activity Summary to the scheduled
+   * activity so it renders meaningfully in the Temporal UI. Falls back to the base stub when no
+   * {@link ActivityOptions} are known (e.g. when this client was constructed from a user-supplied
+   * stub rather than one of the {@link #create} factories).
+   *
+   * @param clientName the name of the MCP client
+   * @param request the tool call request
+   * @param summary the activity Summary, or null to omit
+   * @return the tool call result
+   */
+  public McpSchema.CallToolResult callTool(
+      String clientName, McpSchema.CallToolRequest request, String summary) {
+    if (summary == null || baseOptions == null) {
+      return activity.callTool(clientName, request);
+    }
+    McpClientActivity stub =
+        Workflow.newActivityStub(
+            McpClientActivity.class,
+            ActivityOptions.newBuilder(baseOptions).setSummary(summary).build());
+    return stub.callTool(clientName, request);
   }
 
   /**

temporal-spring-ai/src/main/java/io/temporal/springai/mcp/McpToolCallback.java

@@ -106,7 +106,8 @@ public String call(String toolInput) {
 
     // Use the original tool name (not prefixed) when calling the MCP server
     McpSchema.CallToolRequest request = new McpSchema.CallToolRequest(tool.name(), arguments);
-    McpSchema.CallToolResult result = client.callTool(clientName, request);
+    String summary = "mcp: " + clientName + "." + tool.name();
+    McpSchema.CallToolResult result = client.callTool(clientName, request, summary);
 
     // Return the result as-is (including errors) so the AI can handle them.
     // For example, an "access denied" error lets the AI suggest a valid path.

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

@@ -85,6 +85,7 @@ public class ActivityChatModel implements ChatModel {
 
   private final ChatModelActivity chatModelActivity;
   private final String modelName;
+  private final ActivityOptions baseOptions;
   private final ToolCallingManager toolCallingManager;
   private final ToolExecutionEligibilityPredicate toolExecutionEligibilityPredicate;
 
@@ -94,7 +95,7 @@ public class ActivityChatModel implements ChatModel {
    * @param chatModelActivity the activity stub for calling the chat model
    */
   public ActivityChatModel(ChatModelActivity chatModelActivity) {
-    this(chatModelActivity, null);
+    this(chatModelActivity, null, null);
   }
 
   /**
@@ -104,8 +105,19 @@ public ActivityChatModel(ChatModelActivity chatModelActivity) {
    * @param modelName the name of the chat model to use, or null for default
    */
   public ActivityChatModel(ChatModelActivity chatModelActivity, String modelName) {
+    this(chatModelActivity, modelName, null);
+  }
+
+  /**
+   * Internal constructor used by {@link #forModel(String, Duration, int)} and friends. When {@code
+   * baseOptions} is non-null, each call rebuilds the activity stub with a per-call Summary on top
+   * of those options so the Temporal UI can label the chat activity meaningfully.
+   */
+  private ActivityChatModel(
+      ChatModelActivity chatModelActivity, String modelName, ActivityOptions baseOptions) {
     this.chatModelActivity = chatModelActivity;
     this.modelName = modelName;
+    this.baseOptions = baseOptions;
     this.toolCallingManager = ToolCallingManager.builder().build();
     this.toolExecutionEligibilityPredicate = new DefaultToolExecutionEligibilityPredicate();
   }
@@ -151,14 +163,13 @@ public static ActivityChatModel forModel(String modelName) {
    * @return an ActivityChatModel for the specified chat model
    */
   public static ActivityChatModel forModel(String modelName, Duration timeout, int maxAttempts) {
-    ChatModelActivity activity =
-        Workflow.newActivityStub(
-            ChatModelActivity.class,
-            ActivityOptions.newBuilder()
-                .setStartToCloseTimeout(timeout)
-                .setRetryOptions(RetryOptions.newBuilder().setMaximumAttempts(maxAttempts).build())
-                .build());
-    return new ActivityChatModel(activity, modelName);
+    ActivityOptions options =
+        ActivityOptions.newBuilder()
+            .setStartToCloseTimeout(timeout)
+            .setRetryOptions(RetryOptions.newBuilder().setMaximumAttempts(maxAttempts).build())
+            .build();
+    ChatModelActivity activity = Workflow.newActivityStub(ChatModelActivity.class, options);
+    return new ActivityChatModel(activity, modelName, options);
   }
 
   /**
@@ -193,7 +204,8 @@ public ChatResponse call(Prompt prompt) {
   private ChatResponse internalCall(Prompt prompt) {
     // Convert prompt to activity input and call the activity
     ChatModelTypes.ChatModelActivityInput input = createActivityInput(prompt);
-    ChatModelTypes.ChatModelActivityOutput output = chatModelActivity.callChatModel(input);
+    ChatModelActivity stub = stubForCall(prompt);
+    ChatModelTypes.ChatModelActivityOutput output = stub.callChatModel(input);
 
     // Convert activity output to ChatResponse
     ChatResponse response = toResponse(output);
@@ -219,6 +231,36 @@ private ChatResponse internalCall(Prompt prompt) {
     return response;
   }
 
+  private ChatModelActivity stubForCall(Prompt prompt) {
+    if (baseOptions == null) {
+      return chatModelActivity;
+    }
+    ActivityOptions withSummary =
+        ActivityOptions.newBuilder(baseOptions).setSummary(buildSummary(prompt)).build();
+    return Workflow.newActivityStub(ChatModelActivity.class, withSummary);
+  }
+
+  private String buildSummary(Prompt prompt) {
+    String label = modelName != null ? modelName : "default";
+    String userText = lastUserText(prompt);
+    if (userText == null || userText.isEmpty()) {
+      return "chat: " + label;
+    }
+    String truncated = userText.length() > 60 ? userText.substring(0, 60) + "…" : userText;
+    return "chat: " + label + " · " + truncated.replace('\n', ' ');
+  }
+
+  private String lastUserText(Prompt prompt) {
+    List<Message> instructions = prompt.getInstructions();
+    for (int i = instructions.size() - 1; i >= 0; i--) {
+      Message m = instructions.get(i);
+      if (m.getMessageType() == MessageType.USER) {
+        return m.getText();
+      }
+    }
+    return null;
+  }
+
   private ChatModelTypes.ChatModelActivityInput createActivityInput(Prompt prompt) {
     // Convert messages
     List<ChatModelTypes.Message> messages =

temporal-spring-ai/src/test/java/io/temporal/springai/ActivitySummaryTest.java

@@ -63,8 +63,7 @@ void chatActivity_carriesSummaryWithModelAndUserPrompt() {
     workflow.chat("What is the capital of France?");
 
     String workflowId = WorkflowStub.fromTyped(workflow).getExecution().getWorkflowId();
-    List<HistoryEvent> events =
-        client.fetchHistory(workflowId).getHistory().getEventsList();
+    List<HistoryEvent> events = client.fetchHistory(workflowId).getHistory().getEventsList();
 
     String summary = findChatActivitySummary(events);
     assertNotNull(summary, "ActivityTaskScheduled event for callChatModel should have a Summary");
@@ -83,7 +82,7 @@ private static String findChatActivitySummary(List<HistoryEvent> events) {
       }
       String activityType =
           event.getActivityTaskScheduledEventAttributes().getActivityType().getName();
-      if (!"callChatModel".equals(activityType)) {
+      if (!"CallChatModel".equals(activityType)) {
         continue;
       }
       if (!event.hasUserMetadata() || !event.getUserMetadata().hasSummary()) {