@mastra/acp 0.0.0-ag-example-20260516005230

package/dist/index.cjs

@@ -0,0 +1,620 @@
+'use strict';
+
+var crypto = require('crypto');
+var web = require('stream/web');
+var messageList = require('@mastra/core/agent/message-list');
+var child_process = require('child_process');
+var process = require('process');
+var stream = require('stream');
+var sdk = require('@agentclientprotocol/sdk');
+var workspace = require('@mastra/core/workspace');
+var tools = require('@mastra/core/tools');
+var zod = require('zod');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var process__default = /*#__PURE__*/_interopDefault(process);
+
+// src/agent.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 {};
+  }
+};
+var ACPConnection = class {
+  options;
+  agentProcess;
+  connection;
+  session;
+  initializePromise;
+  currentPrompt;
+  stderr = "";
+  constructor(options) {
+    this.options = options;
+  }
+  get sessionId() {
+    return this.session?.sessionId;
+  }
+  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 = child_process.spawn(this.options.command, this.options.args ?? [], {
+      cwd: this.options.cwd,
+      env: { ...process__default.default.env, ...this.options.env },
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    this.agentProcess.stderr.on("data", (chunk) => {
+      this.stderr += String(chunk);
+    });
+    const stream$1 = sdk.ndJsonStream(
+      stream.Writable.toWeb(this.agentProcess.stdin),
+      stream.Readable.toWeb(this.agentProcess.stdout)
+    );
+    const workspace$1 = this.options.workspace ?? new workspace.Workspace({
+      filesystem: new workspace.LocalFilesystem({ basePath: this.options.cwd ?? process__default.default.cwd() })
+    });
+    this.connection = new sdk.ClientSideConnection(
+      () => new ACPClient(() => this.currentPrompt, workspace$1, this.options.onPermissionRequest),
+      stream$1
+    );
+    try {
+      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());
+    } catch (error) {
+      this.disconnect();
+      throw this.withStderr(error);
+    }
+  }
+  getInitializeRequest() {
+    return {
+      protocolVersion: sdk.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__default.default.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));
+  }
+};
+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 };
+    }
+  };
+}
+function selectedPermissionOutcome(option) {
+  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 web.ReadableStream({
+      start: async (controller) => {
+        controller.close();
+      }
+    })
+  }),
+  doStream: async () => ({
+    stream: new web.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 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 ?? crypto.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 ?? crypto.randomUUID();
+    const prompt = this.getPrompt(messages, options?.instructions);
+    const signal = options?.abortSignal;
+    const messageList$1 = new messageList.MessageList();
+    messageList$1.add(messages, "input");
+    let resolveText;
+    let rejectText;
+    const textPromise = new Promise((resolve, reject) => {
+      resolveText = resolve;
+      rejectText = reject;
+    });
+    const fullStream = new web.ReadableStream({
+      start: async (controller) => {
+        const textId = crypto.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$1.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: messageList$1, toolResults }));
+          resolveText(text);
+          controller.close();
+        } catch (error) {
+          const text = chunks.join("");
+          await options?.onFinish?.(createOnFinishResult({ text, runId, messageList: messageList$1, toolResults, error }));
+          rejectText(error);
+          controller.error(error);
+        }
+      }
+    });
+    return {
+      fullStream,
+      text: textPromise,
+      messageList: messageList$1,
+      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$1 = new messageList.MessageList();
+    messageList$1.add(messages, "input");
+    messageList$1.add([{ role: "assistant", content: text }], "response");
+    return messageList$1;
+  }
+};
+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$1 = new messageList.MessageList();
+  messageList$1.add(messages, "input");
+  return messageList$1.get.all.core().map((message) => messageList.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 messageList.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 [];
+  }
+}
+function getToolName(update, toolNames) {
+  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 };
+}
+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: crypto.randomUUID(),
+      output: {
+        steps: [],
+        usage: { inputTokens: 0, outputTokens: 0, totalTokens: 0 }
+      },
+      stepResult: {
+        reason: "stop",
+        warnings: [],
+        isContinued: false
+      },
+      metadata: {},
+      messages: { nonUser: [], all: [] }
+    }
+  };
+}
+function createACPTool(options) {
+  return tools.createTool({
+    id: options.id,
+    description: options.description,
+    inputSchema: zod.z.object({
+      task: zod.z.string().describe("The task to send to the ACP agent")
+    }),
+    outputSchema: zod.z.object({
+      output: zod.z.string().describe("The output of the ACP agent")
+    }),
+    suspendSchema: zod.z.object({
+      permissionRequest: zod.z.object({
+        title: zod.z.string().describe("The title of the permission request"),
+        options: zod.z.array(
+          zod.z.object({
+            optionId: zod.z.string().describe("The option id to select"),
+            name: zod.z.string().describe("The title of the permission request")
+          })
+        )
+      })
+    }),
+    resumeSchema: zod.z.union([
+      zod.z.object({
+        optionId: zod.z.string().optional().describe("The option id to select"),
+        outcome: zod.z.literal("selected").optional().describe("The outcome of the permission request")
+      }),
+      zod.z.object({
+        outcome: zod.z.literal("cancelled").optional().describe("The outcome of the permission request")
+      })
+    ]),
+    execute: async ({ task }, context) => {
+      const workspace = await context?.mastra?.getWorkspace();
+      const connection = new ACPConnection({
+        ...options,
+        workspace
+      });
+      const output = await connection.prompt(task, context?.abortSignal);
+      return { output };
+    }
+  });
+}
+
+exports.AcpAgent = AcpAgent;
+exports.createACPTool = createACPTool;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map