@mastra/acp 0.4.0 → 0.4.1-alpha.0

package/dist/index.js

@@ -1,750 +1,680 @@
-import { randomUUID } from 'crypto';
-import { ReadableStream } from 'stream/web';
-import { MessageList, coreContentToString } from '@mastra/core/agent/message-list';
-import { spawn } from 'child_process';
-import process from 'process';
-import { Writable, Readable } from 'stream';
-import { ndJsonStream, ClientSideConnection, PROTOCOL_VERSION } from '@agentclientprotocol/sdk';
-import { Workspace, LocalFilesystem } from '@mastra/core/workspace';
-import { createTool } from '@mastra/core/tools';
-
-// src/agent.ts
+import { randomUUID } from "crypto";
+import { ReadableStream } from "stream/web";
+import { MessageList, coreContentToString } from "@mastra/core/agent/message-list";
+import { spawn } from "child_process";
+import process from "process";
+import { Readable, Writable } from "stream";
+import { ClientSideConnection, PROTOCOL_VERSION, ndJsonStream } from "@agentclientprotocol/sdk";
+import { LocalFilesystem, Workspace } from "@mastra/core/workspace";
+import { createTool } from "@mastra/core/tools";
+//#region src/connection.ts
 var ACPClient = class {
-  constructor(getPromptState, workspace, onPermissionRequest) {
-    this.getPromptState = getPromptState;
-    this.workspace = workspace;
-    this.onPermissionRequest = onPermissionRequest;
-  }
-  getPromptState;
-  workspace;
-  onPermissionRequest;
-  async sessionUpdate(notification) {
-    const state = this.getPromptState();
-    if (!state || notification.sessionId !== state.sessionId) {
-      return;
-    }
-    const update = notification.update;
-    if (update.sessionUpdate === "agent_message_chunk") {
-      if (update.content.type === "text") {
-        state.onEvent?.({ type: "text", text: update.content.text });
-      }
-    } else {
-      state.onEvent?.({ type: "session-update", update });
-    }
-  }
-  async requestPermission(request) {
-    if (this.onPermissionRequest) {
-      return this.onPermissionRequest(request);
-    }
-    const option = request.options[0];
-    if (!option) {
-      return { outcome: { outcome: "cancelled" } };
-    }
-    return { outcome: selectedPermissionOutcome(option) };
-  }
-  async readTextFile(params) {
-    let content = await this.workspace.filesystem?.readFile(params.path);
-    if (!(typeof content === "string")) {
-      const decoder = new TextDecoder("utf-8");
-      content = decoder.decode(content);
-    }
-    if (params.line != null || params.limit != null) {
-      const lines = content.split("\n");
-      const start = (params.line ?? 1) - 1;
-      const end = params.limit != null ? start + params.limit : lines.length;
-      return { content: lines.slice(start, end).join("\n") };
-    }
-    return { content };
-  }
-  async writeTextFile(params) {
-    await this.workspace.filesystem?.writeFile(params.path, params.content);
-    return {};
-  }
+	getPromptState;
+	workspace;
+	onPermissionRequest;
+	constructor(getPromptState, workspace, onPermissionRequest) {
+		this.getPromptState = getPromptState;
+		this.workspace = workspace;
+		this.onPermissionRequest = onPermissionRequest;
+	}
+	async sessionUpdate(notification) {
+		const state = this.getPromptState();
+		if (!state || notification.sessionId !== state.sessionId) return;
+		const update = notification.update;
+		if (update.sessionUpdate === "agent_message_chunk") {
+			if (update.content.type === "text") state.onEvent?.({
+				type: "text",
+				text: update.content.text
+			});
+		} else state.onEvent?.({
+			type: "session-update",
+			update
+		});
+	}
+	async requestPermission(request) {
+		if (this.onPermissionRequest) return this.onPermissionRequest(request);
+		const option = request.options[0];
+		if (!option) return { outcome: { outcome: "cancelled" } };
+		return { outcome: selectedPermissionOutcome(option) };
+	}
+	async readTextFile(params) {
+		let content = await this.workspace.filesystem?.readFile(params.path);
+		if (!(typeof content === "string")) content = new TextDecoder("utf-8").decode(content);
+		if (params.line != null || params.limit != null) {
+			const lines = content.split("\n");
+			const start = (params.line ?? 1) - 1;
+			const end = params.limit != null ? start + params.limit : lines.length;
+			return { content: lines.slice(start, end).join("\n") };
+		}
+		return { content };
+	}
+	async writeTextFile(params) {
+		await this.workspace.filesystem?.writeFile(params.path, params.content);
+		return {};
+	}
 };
 var ACPConnection = class {
-  options;
-  agentProcess;
-  connection;
-  session;
-  initializePromise;
-  currentPrompt;
-  stderr = "";
-  constructor(options) {
-    this.options = options;
-  }
-  get sessionId() {
-    return this.session?.sessionId;
-  }
-  async getAvailableModels() {
-    await this.ensureConnected();
-    return this.session?.models?.availableModels ?? [];
-  }
-  async setModel(modelId) {
-    await this.ensureConnected();
-    const available = this.session?.models?.availableModels;
-    if (available && !available.some((m) => m.modelId === modelId)) {
-      const ids = available.map((m) => m.modelId).join(", ") || "(none)";
-      throw new Error(`Model "${modelId}" is not available. Available models: ${ids}`);
-    }
-    await this.connection.unstable_setSessionModel({
-      sessionId: this.session.sessionId,
-      modelId
-    });
-  }
-  async prompt(task, signal) {
-    const parts = [];
-    for await (const event of this.promptStream(task, signal)) {
-      if (event.type === "text") {
-        parts.push(event.text);
-      }
-    }
-    return parts.join("");
-  }
-  async *promptStream(task, signal) {
-    await this.ensureConnected();
-    const sessionId = this.session?.sessionId;
-    if (!this.connection || !sessionId) {
-      throw new Error("ACP connection is not initialized");
-    }
-    if (signal?.aborted) {
-      await this.cancel();
-      throw signal.reason ?? new Error("ACP prompt aborted");
-    }
-    const queue = createAsyncQueue();
-    const state = {
-      sessionId,
-      onEvent: (event) => queue.push(event)
-    };
-    this.currentPrompt = state;
-    const abortHandler = () => {
-      void this.cancel();
-      queue.throw(signal?.reason ?? new Error("ACP prompt aborted"));
-    };
-    signal?.addEventListener("abort", abortHandler, { once: true });
-    const responsePromise = this.connection.prompt({
-      sessionId,
-      prompt: [{ type: "text", text: task }]
-    }).then(
-      (response) => {
-        this.throwIfPromptDidNotComplete(response);
-        queue.close();
-      },
-      (error) => {
-        queue.throw(this.withStderr(error));
-      }
-    );
-    try {
-      for await (const chunk of queue) {
-        yield chunk;
-      }
-      await responsePromise;
-    } catch (error) {
-      await responsePromise.catch(() => void 0);
-      throw error;
-    } finally {
-      signal?.removeEventListener("abort", abortHandler);
-      if (this.currentPrompt === state) {
-        this.currentPrompt = void 0;
-      }
-      if (this.options.persistSession === false) {
-        this.disconnect();
-      }
-    }
-  }
-  async cancel() {
-    const sessionId = this.session?.sessionId;
-    if (!this.connection || !sessionId) {
-      return;
-    }
-    await this.connection.cancel({ sessionId });
-  }
-  disconnect() {
-    this.connection = void 0;
-    this.session = void 0;
-    this.initializePromise = void 0;
-    this.currentPrompt = void 0;
-    if (this.agentProcess && !this.agentProcess.killed) {
-      this.agentProcess.kill();
-    }
-    this.agentProcess = void 0;
-  }
-  async ensureConnected() {
-    if (this.connection && this.session) {
-      return;
-    }
-    this.initializePromise ??= this.initialize();
-    await this.initializePromise;
-  }
-  async initialize() {
-    this.stderr = "";
-    this.agentProcess = spawn(this.options.command, this.options.args ?? [], {
-      cwd: this.options.cwd,
-      env: { ...process.env, ...this.options.env },
-      stdio: ["pipe", "pipe", "pipe"]
-    });
-    const processFailure = new Promise((_, reject) => {
-      this.agentProcess.on("error", (error) => {
-        reject(error instanceof Error ? error : new Error(String(error)));
-      });
-      this.agentProcess.on("exit", (code, signal) => {
-        reject(new Error(`ACP agent process exited during initialization (code: ${code}, signal: ${signal})`));
-      });
-    });
-    processFailure.catch(() => void 0);
-    this.agentProcess.stderr.on("data", (chunk) => {
-      this.stderr += String(chunk);
-    });
-    const stream = ndJsonStream(
-      Writable.toWeb(this.agentProcess.stdin),
-      Readable.toWeb(this.agentProcess.stdout)
-    );
-    const workspace = this.options.workspace ?? new Workspace({
-      filesystem: new LocalFilesystem({ basePath: this.options.cwd ?? process.cwd() })
-    });
-    try {
-      this.connection = new ClientSideConnection(() => {
-        const defaultClient = new ACPClient(() => this.currentPrompt, workspace, this.options.onPermissionRequest);
-        return this.options.createClient?.(defaultClient) ?? defaultClient;
-      }, stream);
-      await Promise.race([processFailure, this.initializeSession()]);
-    } catch (error) {
-      this.disconnect();
-      throw this.withStderr(error);
-    }
-  }
-  async initializeSession() {
-    await this.connection.initialize(this.getInitializeRequest());
-    if (this.options.authMethodId) {
-      await this.connection.authenticate({ methodId: this.options.authMethodId });
-    }
-    this.session = await this.connection.newSession(this.getNewSessionRequest());
-    if (this.options.model) {
-      const available = this.session.models?.availableModels;
-      if (available && !available.some((m) => m.modelId === this.options.model)) {
-        const ids = available.map((m) => m.modelId).join(", ") || "(none)";
-        throw new Error(`Model "${this.options.model}" is not available. Available models: ${ids}`);
-      }
-      await this.connection.unstable_setSessionModel({
-        sessionId: this.session.sessionId,
-        modelId: this.options.model
-      });
-    }
-  }
-  getInitializeRequest() {
-    return {
-      protocolVersion: PROTOCOL_VERSION,
-      clientCapabilities: {
-        fs: { readTextFile: true, writeTextFile: true }
-      },
-      clientInfo: {
-        name: "@mastra/acp",
-        version: "0.1.0"
-      },
-      ...this.options.initialize
-    };
-  }
-  getNewSessionRequest() {
-    return {
-      cwd: this.options.cwd ?? process.cwd(),
-      mcpServers: [],
-      ...this.options.session
-    };
-  }
-  throwIfPromptDidNotComplete(response) {
-    if (response.stopReason === "end_turn") {
-      return;
-    }
-    throw new Error(`ACP prompt stopped before completing: ${response.stopReason}`);
-  }
-  withStderr(error) {
-    const stderr = this.stderr.trim();
-    if (error instanceof Error) {
-      if (stderr && !error.message.includes(stderr)) {
-        error.message = `${error.message}
-
-ACP agent stderr:
-${stderr}`;
-      }
-      return error;
-    }
-    return new Error(stderr ? `${String(error)}
-
-ACP agent stderr:
-${stderr}` : String(error));
-  }
+	options;
+	agentProcess;
+	connection;
+	session;
+	initializePromise;
+	currentPrompt;
+	stderr = "";
+	constructor(options) {
+		this.options = options;
+	}
+	get sessionId() {
+		return this.session?.sessionId;
+	}
+	async getAvailableModels() {
+		await this.ensureConnected();
+		return this.session?.models?.availableModels ?? [];
+	}
+	async setModel(modelId) {
+		await this.ensureConnected();
+		const available = this.session?.models?.availableModels;
+		if (available && !available.some((m) => m.modelId === modelId)) {
+			const ids = available.map((m) => m.modelId).join(", ") || "(none)";
+			throw new Error(`Model "${modelId}" is not available. Available models: ${ids}`);
+		}
+		await this.connection.unstable_setSessionModel({
+			sessionId: this.session.sessionId,
+			modelId
+		});
+	}
+	async prompt(task, signal) {
+		const parts = [];
+		for await (const event of this.promptStream(task, signal)) if (event.type === "text") parts.push(event.text);
+		return parts.join("");
+	}
+	async *promptStream(task, signal) {
+		await this.ensureConnected();
+		const sessionId = this.session?.sessionId;
+		if (!this.connection || !sessionId) throw new Error("ACP connection is not initialized");
+		if (signal?.aborted) {
+			await this.cancel();
+			throw signal.reason ?? /* @__PURE__ */ new Error("ACP prompt aborted");
+		}
+		const queue = createAsyncQueue();
+		const state = {
+			sessionId,
+			onEvent: (event) => queue.push(event)
+		};
+		this.currentPrompt = state;
+		const abortHandler = () => {
+			this.cancel();
+			queue.throw(signal?.reason ?? /* @__PURE__ */ new Error("ACP prompt aborted"));
+		};
+		signal?.addEventListener("abort", abortHandler, { once: true });
+		const responsePromise = this.connection.prompt({
+			sessionId,
+			prompt: [{
+				type: "text",
+				text: task
+			}]
+		}).then((response) => {
+			this.throwIfPromptDidNotComplete(response);
+			queue.close();
+		}, (error) => {
+			queue.throw(this.withStderr(error));
+		});
+		try {
+			for await (const chunk of queue) yield chunk;
+			await responsePromise;
+		} catch (error) {
+			await responsePromise.catch(() => void 0);
+			throw error;
+		} finally {
+			signal?.removeEventListener("abort", abortHandler);
+			if (this.currentPrompt === state) this.currentPrompt = void 0;
+			if (this.options.persistSession === false) this.disconnect();
+		}
+	}
+	async cancel() {
+		const sessionId = this.session?.sessionId;
+		if (!this.connection || !sessionId) return;
+		await this.connection.cancel({ sessionId });
+	}
+	disconnect() {
+		this.connection = void 0;
+		this.session = void 0;
+		this.initializePromise = void 0;
+		this.currentPrompt = void 0;
+		if (this.agentProcess && !this.agentProcess.killed) this.agentProcess.kill();
+		this.agentProcess = void 0;
+	}
+	async ensureConnected() {
+		if (this.connection && this.session) return;
+		this.initializePromise ??= this.initialize();
+		await this.initializePromise;
+	}
+	async initialize() {
+		this.stderr = "";
+		this.agentProcess = spawn(this.options.command, this.options.args ?? [], {
+			cwd: this.options.cwd,
+			env: {
+				...process.env,
+				...this.options.env
+			},
+			stdio: [
+				"pipe",
+				"pipe",
+				"pipe"
+			]
+		});
+		const processFailure = new Promise((_, reject) => {
+			this.agentProcess.on("error", (error) => {
+				reject(error instanceof Error ? error : new Error(String(error)));
+			});
+			this.agentProcess.on("exit", (code, signal) => {
+				reject(/* @__PURE__ */ new Error(`ACP agent process exited during initialization (code: ${code}, signal: ${signal})`));
+			});
+		});
+		processFailure.catch(() => void 0);
+		this.agentProcess.stderr.on("data", (chunk) => {
+			this.stderr += String(chunk);
+		});
+		const stream = ndJsonStream(Writable.toWeb(this.agentProcess.stdin), Readable.toWeb(this.agentProcess.stdout));
+		const workspace = this.options.workspace ?? new Workspace({ filesystem: new LocalFilesystem({ basePath: this.options.cwd ?? process.cwd() }) });
+		try {
+			this.connection = new ClientSideConnection(() => {
+				const defaultClient = new ACPClient(() => this.currentPrompt, workspace, this.options.onPermissionRequest);
+				return this.options.createClient?.(defaultClient) ?? defaultClient;
+			}, stream);
+			await Promise.race([processFailure, this.initializeSession()]);
+		} catch (error) {
+			this.disconnect();
+			throw this.withStderr(error);
+		}
+	}
+	async initializeSession() {
+		await this.connection.initialize(this.getInitializeRequest());
+		if (this.options.authMethodId) await this.connection.authenticate({ methodId: this.options.authMethodId });
+		this.session = await this.connection.newSession(this.getNewSessionRequest());
+		if (this.options.model) {
+			const available = this.session.models?.availableModels;
+			if (available && !available.some((m) => m.modelId === this.options.model)) {
+				const ids = available.map((m) => m.modelId).join(", ") || "(none)";
+				throw new Error(`Model "${this.options.model}" is not available. Available models: ${ids}`);
+			}
+			await this.connection.unstable_setSessionModel({
+				sessionId: this.session.sessionId,
+				modelId: this.options.model
+			});
+		}
+	}
+	getInitializeRequest() {
+		return {
+			protocolVersion: PROTOCOL_VERSION,
+			clientCapabilities: { fs: {
+				readTextFile: true,
+				writeTextFile: true
+			} },
+			clientInfo: {
+				name: "@mastra/acp",
+				version: "0.1.0"
+			},
+			...this.options.initialize
+		};
+	}
+	getNewSessionRequest() {
+		return {
+			cwd: this.options.cwd ?? process.cwd(),
+			mcpServers: [],
+			...this.options.session
+		};
+	}
+	throwIfPromptDidNotComplete(response) {
+		if (response.stopReason === "end_turn") return;
+		throw new Error(`ACP prompt stopped before completing: ${response.stopReason}`);
+	}
+	withStderr(error) {
+		const stderr = this.stderr.trim();
+		if (error instanceof Error) {
+			if (stderr && !error.message.includes(stderr)) error.message = `${error.message}\n\nACP agent stderr:\n${stderr}`;
+			return error;
+		}
+		return new Error(stderr ? `${String(error)}\n\nACP agent stderr:\n${stderr}` : String(error));
+	}
 };
 function createAsyncQueue() {
-  const values = [];
-  const waiters = [];
-  let closed = false;
-  let error;
-  const next = () => {
-    if (values.length > 0) {
-      return Promise.resolve({ value: values.shift(), done: false });
-    }
-    if (error) {
-      return Promise.reject(error);
-    }
-    if (closed) {
-      return Promise.resolve({ value: void 0, done: true });
-    }
-    return new Promise((resolve, reject) => {
-      waiters.push({ resolve, reject });
-    });
-  };
-  return {
-    push(value) {
-      const waiter = waiters.shift();
-      if (waiter) {
-        waiter.resolve({ value, done: false });
-        return;
-      }
-      values.push(value);
-    },
-    close() {
-      closed = true;
-      for (const waiter of waiters.splice(0)) {
-        waiter.resolve({ value: void 0, done: true });
-      }
-    },
-    throw(queueError) {
-      error = queueError;
-      for (const waiter of waiters.splice(0)) {
-        waiter.reject(queueError);
-      }
-    },
-    [Symbol.asyncIterator]() {
-      return { next };
-    }
-  };
+	const values = [];
+	const waiters = [];
+	let closed = false;
+	let error;
+	const next = () => {
+		if (values.length > 0) return Promise.resolve({
+			value: values.shift(),
+			done: false
+		});
+		if (error) return Promise.reject(error);
+		if (closed) return Promise.resolve({
+			value: void 0,
+			done: true
+		});
+		return new Promise((resolve, reject) => {
+			waiters.push({
+				resolve,
+				reject
+			});
+		});
+	};
+	return {
+		push(value) {
+			const waiter = waiters.shift();
+			if (waiter) {
+				waiter.resolve({
+					value,
+					done: false
+				});
+				return;
+			}
+			values.push(value);
+		},
+		close() {
+			closed = true;
+			for (const waiter of waiters.splice(0)) waiter.resolve({
+				value: void 0,
+				done: true
+			});
+		},
+		throw(queueError) {
+			error = queueError;
+			for (const waiter of waiters.splice(0)) waiter.reject(queueError);
+		},
+		[Symbol.asyncIterator]() {
+			return { next };
+		}
+	};
 }
 function selectedPermissionOutcome(option) {
-  return { outcome: "selected", optionId: option.optionId };
+	return {
+		outcome: "selected",
+		optionId: option.optionId
+	};
 }
-
-// src/agent.ts
-var CHUNK_FROM_AGENT = "AGENT";
-var model = {
-  modelId: "acp-agent",
-  provider: "@mastra/acp",
-  specificationVersion: "v3",
-  supportedUrls: {},
-  doGenerate: async () => ({
-    stream: new ReadableStream({
-      start: async (controller) => {
-        controller.close();
-      }
-    })
-  }),
-  doStream: async () => ({
-    stream: new ReadableStream({
-      start: async (controller) => {
-        controller.close();
-      }
-    })
-  })
+//#endregion
+//#region src/agent.ts
+const CHUNK_FROM_AGENT = "AGENT";
+const model = {
+	modelId: "acp-agent",
+	provider: "@mastra/acp",
+	specificationVersion: "v3",
+	supportedUrls: {},
+	doGenerate: async () => ({ stream: new ReadableStream({ start: async (controller) => {
+		controller.close();
+	} }) }),
+	doStream: async () => ({ stream: new ReadableStream({ start: async (controller) => {
+		controller.close();
+	} }) })
 };
 var AcpAgent = class {
-  id;
-  name;
-  connection;
-  description;
-  constructor(options) {
-    this.id = options.id;
-    this.name = options.name ?? options.id;
-    this.description = options.description;
-    this.connection = new ACPConnection(options);
-  }
-  __registerMastra(_mastra) {
-  }
-  getDescription() {
-    return this.description;
-  }
-  getModel() {
-    return model;
-  }
-  hasOwnMemory() {
-    return false;
-  }
-  __setMemory(_memory) {
-  }
-  getMemory() {
-    return void 0;
-  }
-  getInstructions() {
-    return "";
-  }
-  async getAvailableModels() {
-    return this.connection.getAvailableModels();
-  }
-  async setModel(modelId) {
-    return this.connection.setModel(modelId);
-  }
-  async generate(messages, options) {
-    const prompt = this.getPrompt(messages, options?.instructions);
-    const text = await this.connection.prompt(
-      prompt,
-      options?.abortSignal
-    );
-    const messageList = this.createMessageList(messages, text);
-    return {
-      text,
-      response: {
-        dbMessages: messageList.get.response.db()
-      },
-      toolResults: [],
-      finishReason: "stop",
-      runId: options?.runId ?? randomUUID()
-    };
-  }
-  async resumeGenerate() {
-    throw new Error("AcpAgent does not support resuming suspended generate calls");
-  }
-  async resumeStream() {
-    throw new Error("AcpAgent does not support resuming suspended stream calls");
-  }
-  async stream(messages, options) {
-    const runId = options?.runId ?? randomUUID();
-    const prompt = this.getPrompt(messages, options?.instructions);
-    const signal = options?.abortSignal;
-    const messageList = new MessageList();
-    messageList.add(messages, "input");
-    let resolveText;
-    let rejectText;
-    const textPromise = new Promise((resolve, reject) => {
-      resolveText = resolve;
-      rejectText = reject;
-    });
-    const fullStream = new ReadableStream({
-      start: async (controller) => {
-        const textId = randomUUID();
-        const chunks = [];
-        const toolNames = /* @__PURE__ */ new Map();
-        const toolResults = [];
-        try {
-          controller.enqueue({ type: "text-start", runId, from: CHUNK_FROM_AGENT, payload: { id: textId } });
-          for await (const event of this.connection.promptStream(prompt, signal)) {
-            if (event.type === "text") {
-              chunks.push(event.text);
-              controller.enqueue({
-                type: "text-delta",
-                runId,
-                from: CHUNK_FROM_AGENT,
-                payload: { id: textId, text: event.text }
-              });
-            } else if (event.type === "session-update") {
-              for (const chunk of getMastraChunksFromACPUpdate(event.update, runId, toolNames)) {
-                if (chunk.type === "tool-result") {
-                  toolResults.push({ payload: chunk.payload });
-                }
-                controller.enqueue(chunk);
-              }
-            }
-          }
-          const text = chunks.join("");
-          messageList.add([{ role: "assistant", content: text }], "response");
-          controller.enqueue({ type: "text-end", runId, from: CHUNK_FROM_AGENT, payload: { id: textId } });
-          controller.enqueue(createFinishChunk("step-finish", runId));
-          controller.enqueue(createFinishChunk("finish", runId));
-          await options?.onFinish?.(createOnFinishResult({ text, runId, messageList, toolResults }));
-          resolveText(text);
-          controller.close();
-        } catch (error) {
-          const text = chunks.join("");
-          await options?.onFinish?.(createOnFinishResult({ text, runId, messageList, toolResults, error }));
-          rejectText(error);
-          controller.error(error);
-        }
-      }
-    });
-    return {
-      fullStream,
-      text: textPromise,
-      messageList,
-      toolResults: [],
-      runId
-    };
-  }
-  getPrompt(messages, instructions) {
-    const prompt = extractText(messages);
-    const instructionText = instructions ? extractInstructions(instructions) : "";
-    if (!instructionText) {
-      return prompt;
-    }
-    return `${instructionText}
-
-${prompt}`;
-  }
-  createMessageList(messages, text) {
-    const messageList = new MessageList();
-    messageList.add(messages, "input");
-    messageList.add([{ role: "assistant", content: text }], "response");
-    return messageList;
-  }
+	id;
+	name;
+	connection;
+	description;
+	constructor(options) {
+		this.id = options.id;
+		this.name = options.name ?? options.id;
+		this.description = options.description;
+		this.connection = new ACPConnection(options);
+	}
+	__registerMastra(_mastra) {}
+	getDescription() {
+		return this.description;
+	}
+	getModel() {
+		return model;
+	}
+	hasOwnMemory() {
+		return false;
+	}
+	__setMemory(_memory) {}
+	getMemory() {}
+	getInstructions() {
+		return "";
+	}
+	async getAvailableModels() {
+		return this.connection.getAvailableModels();
+	}
+	async setModel(modelId) {
+		return this.connection.setModel(modelId);
+	}
+	async generate(messages, options) {
+		const prompt = this.getPrompt(messages, options?.instructions);
+		const text = await this.connection.prompt(prompt, options?.abortSignal);
+		return {
+			text,
+			response: { dbMessages: this.createMessageList(messages, text).get.response.db() },
+			toolResults: [],
+			finishReason: "stop",
+			runId: options?.runId ?? randomUUID()
+		};
+	}
+	async resumeGenerate() {
+		throw new Error("AcpAgent does not support resuming suspended generate calls");
+	}
+	async resumeStream() {
+		throw new Error("AcpAgent does not support resuming suspended stream calls");
+	}
+	async stream(messages, options) {
+		const runId = options?.runId ?? randomUUID();
+		const prompt = this.getPrompt(messages, options?.instructions);
+		const signal = options?.abortSignal;
+		const messageList = new MessageList();
+		messageList.add(messages, "input");
+		let resolveText;
+		let rejectText;
+		const textPromise = new Promise((resolve, reject) => {
+			resolveText = resolve;
+			rejectText = reject;
+		});
+		return {
+			fullStream: new ReadableStream({ start: async (controller) => {
+				const textId = randomUUID();
+				const chunks = [];
+				const toolNames = /* @__PURE__ */ new Map();
+				const toolResults = [];
+				try {
+					controller.enqueue({
+						type: "text-start",
+						runId,
+						from: CHUNK_FROM_AGENT,
+						payload: { id: textId }
+					});
+					for await (const event of this.connection.promptStream(prompt, signal)) if (event.type === "text") {
+						chunks.push(event.text);
+						controller.enqueue({
+							type: "text-delta",
+							runId,
+							from: CHUNK_FROM_AGENT,
+							payload: {
+								id: textId,
+								text: event.text
+							}
+						});
+					} else if (event.type === "session-update") for (const chunk of getMastraChunksFromACPUpdate(event.update, runId, toolNames)) {
+						if (chunk.type === "tool-result") toolResults.push({ payload: chunk.payload });
+						controller.enqueue(chunk);
+					}
+					const text = chunks.join("");
+					messageList.add([{
+						role: "assistant",
+						content: text
+					}], "response");
+					controller.enqueue({
+						type: "text-end",
+						runId,
+						from: CHUNK_FROM_AGENT,
+						payload: { id: textId }
+					});
+					controller.enqueue(createFinishChunk("step-finish", runId));
+					controller.enqueue(createFinishChunk("finish", runId));
+					await options?.onFinish?.(createOnFinishResult({
+						text,
+						runId,
+						messageList,
+						toolResults
+					}));
+					resolveText(text);
+					controller.close();
+				} catch (error) {
+					const text = chunks.join("");
+					await options?.onFinish?.(createOnFinishResult({
+						text,
+						runId,
+						messageList,
+						toolResults,
+						error
+					}));
+					rejectText(error);
+					controller.error(error);
+				}
+			} }),
+			text: textPromise,
+			messageList,
+			toolResults: [],
+			runId
+		};
+	}
+	getPrompt(messages, instructions) {
+		const prompt = extractText(messages);
+		const instructionText = instructions ? extractInstructions(instructions) : "";
+		if (!instructionText) return prompt;
+		return `${instructionText}\n\n${prompt}`;
+	}
+	createMessageList(messages, text) {
+		const messageList = new MessageList();
+		messageList.add(messages, "input");
+		messageList.add([{
+			role: "assistant",
+			content: text
+		}], "response");
+		return messageList;
+	}
 };
 function extractText(messages) {
-  if (typeof messages === "string") {
-    return messages;
-  }
-  if (Array.isArray(messages) && messages.every((message) => typeof message === "string")) {
-    return messages.join("\n");
-  }
-  const messageList = new MessageList();
-  messageList.add(messages, "input");
-  return messageList.get.all.core().map((message) => coreContentToString(message.content)).filter(Boolean).join("\n");
+	if (typeof messages === "string") return messages;
+	if (Array.isArray(messages) && messages.every((message) => typeof message === "string")) return messages.join("\n");
+	const messageList = new MessageList();
+	messageList.add(messages, "input");
+	return messageList.get.all.core().map((message) => coreContentToString(message.content)).filter(Boolean).join("\n");
 }
 function extractInstructions(instructions) {
-  if (typeof instructions === "string") {
-    return instructions;
-  }
-  if (Array.isArray(instructions)) {
-    return instructions.map((instruction) => extractInstructions(instruction)).join("\n");
-  }
-  return coreContentToString(instructions.content);
+	if (typeof instructions === "string") return instructions;
+	if (Array.isArray(instructions)) return instructions.map((instruction) => extractInstructions(instruction)).join("\n");
+	return coreContentToString(instructions.content);
 }
 function getMastraChunksFromACPUpdate(update, runId, toolNames) {
-  switch (update.sessionUpdate) {
-    case "tool_call": {
-      const toolName = getToolName(update, toolNames);
-      toolNames.set(update.toolCallId, toolName);
-      return [
-        {
-          type: "tool-call",
-          runId,
-          from: CHUNK_FROM_AGENT,
-          payload: {
-            toolCallId: update.toolCallId,
-            toolName,
-            args: toRecord(update.rawInput)
-          }
-        }
-      ];
-    }
-    case "tool_call_update": {
-      const toolName = getToolName(update, toolNames);
-      if (update.status === "completed" || update.status === "failed") {
-        return [
-          {
-            type: "tool-result",
-            runId,
-            from: CHUNK_FROM_AGENT,
-            payload: {
-              toolCallId: update.toolCallId,
-              toolName,
-              result: update.rawOutput ?? update.content ?? { status: update.status, title: update.title },
-              isError: update.status === "failed"
-            }
-          }
-        ];
-      }
-      return [
-        {
-          type: "tool-call-delta",
-          runId,
-          from: CHUNK_FROM_AGENT,
-          payload: {
-            toolCallId: update.toolCallId,
-            toolName,
-            argsTextDelta: update.title ?? update.status ?? ""
-          }
-        }
-      ];
-    }
-    default:
-      return [];
-  }
+	switch (update.sessionUpdate) {
+		case "tool_call": {
+			const toolName = getToolName(update, toolNames);
+			toolNames.set(update.toolCallId, toolName);
+			return [{
+				type: "tool-call",
+				runId,
+				from: CHUNK_FROM_AGENT,
+				payload: {
+					toolCallId: update.toolCallId,
+					toolName,
+					args: toRecord(update.rawInput)
+				}
+			}];
+		}
+		case "tool_call_update": {
+			const toolName = getToolName(update, toolNames);
+			if (update.status === "completed" || update.status === "failed") return [{
+				type: "tool-result",
+				runId,
+				from: CHUNK_FROM_AGENT,
+				payload: {
+					toolCallId: update.toolCallId,
+					toolName,
+					result: update.rawOutput ?? update.content ?? {
+						status: update.status,
+						title: update.title
+					},
+					isError: update.status === "failed"
+				}
+			}];
+			return [{
+				type: "tool-call-delta",
+				runId,
+				from: CHUNK_FROM_AGENT,
+				payload: {
+					toolCallId: update.toolCallId,
+					toolName,
+					argsTextDelta: update.title ?? update.status ?? ""
+				}
+			}];
+		}
+		default: return [];
+	}
 }
 function getToolName(update, toolNames) {
-  return update.title ?? toolNames.get(update.toolCallId) ?? update.kind ?? "acp_tool";
+	return update.title ?? toolNames.get(update.toolCallId) ?? update.kind ?? "acp_tool";
 }
 function toRecord(value) {
-  if (value && typeof value === "object" && !Array.isArray(value)) {
-    return value;
-  }
-  if (value === void 0) {
-    return {};
-  }
-  return { input: value };
+	if (value && typeof value === "object" && !Array.isArray(value)) return value;
+	if (value === void 0) return {};
+	return { input: value };
 }
-function createOnFinishResult({
-  text,
-  runId,
-  messageList,
-  toolResults,
-  error
-}) {
-  const usage = { inputTokens: 0, outputTokens: 0, totalTokens: 0 };
-  return {
-    text,
-    finishReason: "stop",
-    usage,
-    totalUsage: usage,
-    warnings: [],
-    response: {
-      messages: messageList.get.response.aiV5.model()
-    },
-    steps: [],
-    toolResults,
-    runId,
-    ...error === void 0 ? {} : { error }
-  };
+function createOnFinishResult({ text, runId, messageList, toolResults, error }) {
+	const usage = {
+		inputTokens: 0,
+		outputTokens: 0,
+		totalTokens: 0
+	};
+	return {
+		text,
+		finishReason: "stop",
+		usage,
+		totalUsage: usage,
+		warnings: [],
+		response: { messages: messageList.get.response.aiV5.model() },
+		steps: [],
+		toolResults,
+		runId,
+		...error === void 0 ? {} : { error }
+	};
 }
 function createFinishChunk(type, runId) {
-  return {
-    type,
-    runId,
-    from: CHUNK_FROM_AGENT,
-    payload: {
-      id: randomUUID(),
-      output: {
-        steps: [],
-        usage: { inputTokens: 0, outputTokens: 0, totalTokens: 0 }
-      },
-      stepResult: {
-        reason: "stop",
-        warnings: [],
-        isContinued: false
-      },
-      metadata: {},
-      messages: { nonUser: [], all: [] }
-    }
-  };
+	return {
+		type,
+		runId,
+		from: CHUNK_FROM_AGENT,
+		payload: {
+			id: randomUUID(),
+			output: {
+				steps: [],
+				usage: {
+					inputTokens: 0,
+					outputTokens: 0,
+					totalTokens: 0
+				}
+			},
+			stepResult: {
+				reason: "stop",
+				warnings: [],
+				isContinued: false
+			},
+			metadata: {},
+			messages: {
+				nonUser: [],
+				all: []
+			}
+		}
+	};
 }
-
-// src/session.ts
+//#endregion
+//#region src/session.ts
 var ACPToolSession = class {
-  constructor(options) {
-    this.options = options;
-  }
-  options;
-  connection;
-  getConnection(workspace) {
-    if (this.options.persistSession === false) {
-      return this.createConnection(workspace);
-    }
-    this.connection ??= this.createConnection(workspace);
-    return this.connection;
-  }
-  createConnection(workspace) {
-    return new ACPConnection({
-      ...this.options,
-      workspace: workspace ?? this.options.workspace
-    });
-  }
+	options;
+	connection;
+	constructor(options) {
+		this.options = options;
+	}
+	getConnection(workspace) {
+		if (this.options.persistSession === false) return this.createConnection(workspace);
+		this.connection ??= this.createConnection(workspace);
+		return this.connection;
+	}
+	createConnection(workspace) {
+		return new ACPConnection({
+			...this.options,
+			workspace: workspace ?? this.options.workspace
+		});
+	}
 };
-
-// src/tool.ts
+//#endregion
+//#region src/tool.ts
 function createACPTool(options) {
-  const session = new ACPToolSession(options);
-  return createTool({
-    id: options.id,
-    description: options.description,
-    inputSchema: {
-      "$schema": "https://json-schema.org/draft/2020-12/schema",
-      "type": "object",
-      "properties": {
-        "task": {
-          "type": "string",
-          "description": "The task to send to the ACP agent"
-        }
-      },
-      "required": [
-        "task"
-      ]
-    },
-    outputSchema: {
-      "$schema": "https://json-schema.org/draft/2020-12/schema",
-      "type": "object",
-      "properties": {
-        "output": {
-          "type": "string",
-          "description": "The output of the ACP agent"
-        }
-      },
-      "required": [
-        "output"
-      ]
-    },
-    suspendSchema: {
-      "$schema": "https://json-schema.org/draft/2020-12/schema",
-      "type": "object",
-      "properties": {
-        "permissionRequest": {
-          "type": "object",
-          "properties": {
-            "title": {
-              "type": "string",
-              "description": "The title of the permission request"
-            },
-            "options": {
-              "type": "array",
-              "items": {
-                "type": "object",
-                "properties": {
-                  "optionId": {
-                    "type": "string",
-                    "description": "The option id to select"
-                  },
-                  "name": {
-                    "type": "string",
-                    "description": "The title of the permission request"
-                  }
-                },
-                "required": [
-                  "optionId",
-                  "name"
-                ]
-              }
-            }
-          },
-          "required": [
-            "title",
-            "options"
-          ]
-        }
-      },
-      "required": [
-        "permissionRequest"
-      ]
-    },
-    resumeSchema: {
-      "$schema": "https://json-schema.org/draft/2020-12/schema",
-      "anyOf": [
-        {
-          "type": "object",
-          "properties": {
-            "optionId": {
-              "description": "The option id to select",
-              "type": "string"
-            },
-            "outcome": {
-              "description": "The outcome of the permission request",
-              "type": "string",
-              "const": "selected"
-            }
-          }
-        },
-        {
-          "type": "object",
-          "properties": {
-            "outcome": {
-              "description": "The outcome of the permission request",
-              "type": "string",
-              "const": "cancelled"
-            }
-          }
-        }
-      ]
-    },
-    execute: async ({ task }, context) => {
-      const workspace = await context?.mastra?.getWorkspace();
-      const connection = session.getConnection(workspace);
-      const output = await connection.prompt(task, context?.abortSignal);
-      return { output };
-    }
-  });
+	const session = new ACPToolSession(options);
+	return createTool({
+		id: options.id,
+		description: options.description,
+		inputSchema: {
+			"$schema": "https://json-schema.org/draft/2020-12/schema",
+			"type": "object",
+			"properties": { "task": {
+				"type": "string",
+				"description": "The task to send to the ACP agent"
+			} },
+			"required": ["task"]
+		},
+		outputSchema: {
+			"$schema": "https://json-schema.org/draft/2020-12/schema",
+			"type": "object",
+			"properties": { "output": {
+				"type": "string",
+				"description": "The output of the ACP agent"
+			} },
+			"required": ["output"]
+		},
+		suspendSchema: {
+			"$schema": "https://json-schema.org/draft/2020-12/schema",
+			"type": "object",
+			"properties": { "permissionRequest": {
+				"type": "object",
+				"properties": {
+					"title": {
+						"type": "string",
+						"description": "The title of the permission request"
+					},
+					"options": {
+						"type": "array",
+						"items": {
+							"type": "object",
+							"properties": {
+								"optionId": {
+									"type": "string",
+									"description": "The option id to select"
+								},
+								"name": {
+									"type": "string",
+									"description": "The title of the permission request"
+								}
+							},
+							"required": ["optionId", "name"]
+						}
+					}
+				},
+				"required": ["title", "options"]
+			} },
+			"required": ["permissionRequest"]
+		},
+		resumeSchema: {
+			"$schema": "https://json-schema.org/draft/2020-12/schema",
+			"anyOf": [{
+				"type": "object",
+				"properties": {
+					"optionId": {
+						"description": "The option id to select",
+						"type": "string"
+					},
+					"outcome": {
+						"description": "The outcome of the permission request",
+						"type": "string",
+						"const": "selected"
+					}
+				}
+			}, {
+				"type": "object",
+				"properties": { "outcome": {
+					"description": "The outcome of the permission request",
+					"type": "string",
+					"const": "cancelled"
+				} }
+			}]
+		},
+		execute: async ({ task }, context) => {
+			const workspace = await context?.mastra?.getWorkspace();
+			return { output: await session.getConnection(workspace).prompt(task, context?.abortSignal) };
+		}
+	});
 }
-
+//#endregion
 export { AcpAgent, createACPTool };
-//# sourceMappingURL=index.js.map
+
 //# sourceMappingURL=index.js.map