feat(acp-ai-provider): Add session persistence for multi-turn conversations

This introduces session persistence to the ACP AI Provider, enabling multi-turn conversations and the ability to resume previous sessions.

Author: yaonyan

packages/acp-ai-provider/README.md

@@ -108,6 +108,37 @@ const result = await generateText({
 });
 ```
 
+### Session Persistence
+
+Keep sessions alive for multi-turn conversations:
+
+```typescript
+const provider = createACPProvider({
+  command: "gemini",
+  args: ["--experimental-acp"],
+  session: { cwd: process.cwd(), mcpServers: [] },
+  persistSession: true, // Keep session alive
+});
+
+const model = provider.languageModel();
+await generateText({ model, prompt: "Hi, my name is Alice" });
+await generateText({ model, prompt: "What's my name?" }); // Agent remembers
+
+provider.cleanup(); // Clean up when done
+```
+
+Resume a previous session:
+
+```typescript
+const provider = createACPProvider({
+  command: "gemini",
+  args: ["--experimental-acp"],
+  session: { cwd: process.cwd(), mcpServers: [] },
+  existingSessionId: "previous-session-id",
+  persistSession: true,
+});
+```
+
 ## FAQ
 
 ### How to stream tool calls

packages/acp-ai-provider/deno.json

@@ -1,6 +1,6 @@
 {
   "name": "@mcpc/acp-ai-provider",
-  "version": "0.1.21",
+  "version": "0.1.22",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/mcpc-tech/mcpc.git"

packages/acp-ai-provider/src/language-model.ts

@@ -12,7 +12,6 @@ import {
   type ContentBlock,
   type InitializeRequest,
   ndJsonStream,
-  type NewSessionRequest,
   PROTOCOL_VERSION,
   type ReadTextFileRequest,
   type ReadTextFileResponse,
@@ -210,78 +209,58 @@ export class ACPLanguageModel implements LanguageModelV2 {
   }
 
   /**
-   * Converts AI SDK prompt messages into an array of ACP ContentBlock objects.
+   * Converts AI SDK prompt messages into ACP ContentBlock objects.
+   * When session exists, only extracts the last user message (history is in session).
+   * Prefixes text with role since ACP ContentBlock has no role field.
    */
   private getPromptContent(
     options: LanguageModelV2CallOptions,
   ): ContentBlock[] {
-    const contentBlocks: ContentBlock[] = [];
+    // With persistent session, only send the latest user message
+    const messages = this.sessionId
+      ? options.prompt.filter((m) => m.role === "user").slice(-1)
+      : options.prompt;
 
-    for (const msg of options.prompt) {
-      let prefix = "";
-      // Note: ACP doesn't have a "system" role, so we prefix it.
-      if (msg.role === "system") {
-        prefix = "System: ";
-      } else if (msg.role === "user") {
-        prefix = "User: ";
-      } else if (msg.role === "assistant") {
-        prefix = "Assistant: ";
-      }
+    const contentBlocks: ContentBlock[] = [];
 
-      // Note: ACP doesn't have a "tool" role. Tool results are handled
-      // by the agent itself, not by sending a message.
-      if (
-        msg.role === "system" ||
-        msg.role === "user" ||
-        msg.role === "assistant"
-      ) {
-        if (Array.isArray(msg.content)) {
-          for (const part of msg.content) {
-            switch (part.type) {
-              case "text": {
-                contentBlocks.push({
-                  type: "text" as const,
-                  text: `${prefix}${part.text}`,
-                });
-                prefix = ""; // Only prefix the first part
-                break;
-              }
-              case "file": {
-                const type: ContentBlock["type"] | null = (() => {
-                  if (part.mediaType.startsWith("image/")) {
-                    return "image";
-                  }
-                  if (part.mediaType.startsWith("audio/")) {
-                    return "audio";
-                  }
-                  return null;
-                })();
-
-                if (
-                  type === null ||
-                  // Ensure data is string before processing
-                  typeof part.data !== "string"
-                ) {
-                  break;
-                }
-                contentBlocks.push({
-                  type,
-                  mimeType: part.mediaType,
-                  data: extractBase64Data(part.data),
-                });
-
-                break;
-              }
+    for (const msg of messages) {
+      // Skip tool role - ACP handles tool results internally
+      if (msg.role === "tool") continue;
+
+      // Prefix to identify role since ACP has no role field
+      const prefix = msg.role === "system"
+        ? "System: "
+        : msg.role === "assistant"
+        ? "Assistant: "
+        : "";
+
+      if (Array.isArray(msg.content)) {
+        let isFirst = true;
+        for (const part of msg.content) {
+          if (part.type === "text") {
+            const text = isFirst ? `${prefix}${part.text}` : part.text;
+            contentBlocks.push({ type: "text" as const, text });
+            isFirst = false;
+          } else if (part.type === "file" && typeof part.data === "string") {
+            const type = part.mediaType.startsWith("image/")
+              ? "image"
+              : part.mediaType.startsWith("audio/")
+              ? "audio"
+              : null;
+            if (type) {
+              contentBlocks.push({
+                type,
+                mimeType: part.mediaType,
+                data: extractBase64Data(part.data),
+              });
             }
-
-            // Other parts (like images) are ignored in current implementation
           }
-        } else if (typeof msg.content === "string") {
-          contentBlocks.push({
-            type: "text" as const,
-            text: `${prefix}${msg.content}`,
-          });
         }
+      } else if (typeof msg.content === "string") {
+        contentBlocks.push({
+          type: "text" as const,
+          text: `${prefix}${msg.content}`,
+        });
       }
     }
 
@@ -352,25 +331,46 @@ export class ACPLanguageModel implements LanguageModelV2 {
       );
     }
 
-    const sessionConfig: NewSessionRequest = {
-      ...this.config.session,
-      cwd: this.config.session.cwd ?? sessionCwd,
-      mcpServers: this.config.session.mcpServers ?? [],
-    };
+    if (this.config.existingSessionId) {
+      await this.connection.loadSession({
+        sessionId: this.config.existingSessionId,
+        cwd: this.config.session?.cwd ?? sessionCwd,
+        mcpServers: this.config.session?.mcpServers ?? [],
+      });
+      this.sessionId = this.config.existingSessionId;
+    } else {
+      const session = await this.connection.newSession({
+        ...this.config.session,
+        cwd: this.config.session?.cwd ?? sessionCwd,
+        mcpServers: this.config.session?.mcpServers ?? [],
+      });
+      this.sessionId = session.sessionId;
+    }
+  }
 
-    const session = await this.connection.newSession(sessionConfig);
+  /**
+   * Clears connection state. Skips if persistSession is enabled.
+   */
+  private cleanup(): void {
+    if (this.config.persistSession) return;
+    this.forceCleanup();
+  }
 
-    this.sessionId = session.sessionId;
+  /**
+   * Returns the current session ID.
+   */
+  getSessionId(): string | null {
+    return this.sessionId;
   }
 
   /**
-   * Kills the agent process and clears connection state.
+   * Forces cleanup regardless of persistSession setting.
    */
-  private cleanup(): void {
+  forceCleanup(): void {
     if (this.agentProcess) {
       this.agentProcess.kill();
-      this.agentProcess!.stdin?.end();
-      this.agentProcess!.stdout?.destroy();
+      this.agentProcess.stdin?.end();
+      this.agentProcess.stdout?.destroy();
       this.agentProcess = null;
     }
     this.connection = null;

packages/acp-ai-provider/src/provider.ts

@@ -45,41 +45,38 @@ export class ACPProvider {
   get tools(): Record<string, ReturnType<typeof tool>> | undefined {
     return this.model?.tools;
   }
+
+  /**
+   * Returns the current session ID if one is active.
+   * Useful when `persistSession` is enabled and you need to reference the session later.
+   */
+  getSessionId(): string | null {
+    return this.model?.getSessionId() ?? null;
+  }
+
+  /**
+   * Forces cleanup of the connection and session.
+   * Call this when you're done with the provider instance, especially when using `persistSession`.
+   */
+  cleanup(): void {
+    this.model?.forceCleanup();
+  }
 }
 
 /**
  * Create an ACP provider instance
  *
  * @example
  * ```typescript
- * import { createACPProvider } from "@mcpc/acp-client-ai-provider";
- * import { generateText } from "ai";
- *
- * // See ACPProviderSettings in types.ts for all required fields
  * const provider = createACPProvider({
- *   // Process configuration
- *   command: "gemini",                    // Required: Command to execute the ACP agent
- *   args: ["--experimental-acp"],         // Optional: Arguments to pass to the command
- *   env: {},                              // Optional: Environment variables for the agent process
- *
- *   // ACP protocol configuration
- *   session: {                            // Required: Session configuration (NewSessionRequest)
- *     cwd: process.cwd(),
- *     mcpServers: [],
- *   },
- *   // initialize: {                       // Optional: Initialize configuration (InitializeRequest)
- *   //   protocolVersion: 1,
- *   //   clientCapabilities: {
- *   //     fs: { readTextFile: false, writeTextFile: false },
- *   //     terminal: false,
- *   //   },
- *   // },
+ *   command: "gemini",
+ *   args: ["--experimental-acp"],
+ *   session: { cwd: process.cwd(), mcpServers: [] },
  * });
  *
- * // Use with AI SDK
  * const result = await generateText({
  *   model: provider.languageModel(),
- *   prompt: "Hello, world!"
+ *   prompt: "Hello!"
  * });
  * ```
  */

packages/acp-ai-provider/src/types.ts

@@ -33,7 +33,8 @@ export interface ACPProviderSettings {
   env?: Record<string, string>;
 
   /**
-   * Session configuration (ACP protocol) - Required
+   * Session configuration (ACP protocol) - Required when creating a new session
+   * Can be partial when using existingSessionId (only cwd and mcpServers are used)
    */
   session: ACPSessionConfig;
 
@@ -48,4 +49,14 @@ export interface ACPProviderSettings {
    * Set to undefined to use the first available method, and you can see a warning of all available methods.
    */
   authMethodId?: string;
+
+  /**
+   * Load an existing session instead of creating a new one.
+   */
+  existingSessionId?: string;
+
+  /**
+   * Keep connection alive after each call for session reuse.
+   */
+  persistSession?: boolean;
 }

packages/core/src/executors/workflow/workflow-executor.ts

@@ -20,7 +20,8 @@ export class WorkflowExecutor {
     private predefinedSteps?: MCPCStep[],
     private ensureStepActions?: string[],
     private toolNameToIdMapping?: Map<string, string>,
-  ) {}
+  ) {
+  }
 
   // Helper method to validate required actions are present in workflow steps
   private validateRequiredActions(steps: MCPCStep[]): {