@nextclaw/ncp-toolkit 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 NextClaw contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,14 @@
+# @nextclaw/ncp-toolkit
+
+Toolkit implementations built on top of `@nextclaw/ncp` protocol contracts.
+
+## Build
+
+```bash
+pnpm -C packages/nextclaw-ncp-toolkit build
+```
+
+## Scope
+
+- Reference conversation-state manager implementations
+- Protocol-level helper logic that depends on `@nextclaw/ncp` contracts

package/dist/index.d.ts

@@ -0,0 +1,51 @@
+import { NcpAgentConversationStateManager, NcpConversationSnapshot, NcpEndpointEvent, NcpRequestEnvelope, NcpMessageSentPayload, NcpMessageAcceptedPayload, NcpResponseEnvelope, NcpCompletedEnvelope, NcpFailedEnvelope, NcpMessageAbortPayload, NcpTextStartPayload, NcpTextDeltaPayload, NcpTextEndPayload, NcpReasoningStartPayload, NcpReasoningDeltaPayload, NcpReasoningEndPayload, NcpToolCallStartPayload, NcpToolCallArgsPayload, NcpToolCallArgsDeltaPayload, NcpToolCallEndPayload, NcpToolCallResultPayload, NcpRunStartedPayload, NcpRunFinishedPayload, NcpRunErrorPayload, NcpRunMetadataPayload, NcpError } from '@nextclaw/ncp';
+
+declare class DefaultNcpAgentConversationStateManager implements NcpAgentConversationStateManager {
+    private messages;
+    private streamingMessage;
+    private error;
+    private readonly listeners;
+    private readonly toolCallMessageIdByCallId;
+    private readonly toolCallArgsRawByCallId;
+    private stateVersion;
+    getSnapshot(): NcpConversationSnapshot;
+    subscribe(listener: (snapshot: NcpConversationSnapshot) => void): () => boolean;
+    dispatch(event: NcpEndpointEvent): void;
+    handleMessageRequest(payload: NcpRequestEnvelope): void;
+    handleMessageSent(payload: NcpMessageSentPayload): void;
+    handleMessageAccepted(_payload: NcpMessageAcceptedPayload): void;
+    handleMessageIncoming(payload: NcpResponseEnvelope): void;
+    handleMessageCompleted(payload: NcpCompletedEnvelope): void;
+    handleMessageFailed(payload: NcpFailedEnvelope): void;
+    handleMessageAbort(payload: NcpMessageAbortPayload): void;
+    handleMessageTextStart(payload: NcpTextStartPayload): void;
+    handleMessageTextDelta(payload: NcpTextDeltaPayload): void;
+    handleMessageTextEnd(payload: NcpTextEndPayload): void;
+    handleMessageReasoningStart(payload: NcpReasoningStartPayload): void;
+    handleMessageReasoningDelta(payload: NcpReasoningDeltaPayload): void;
+    handleMessageReasoningEnd(payload: NcpReasoningEndPayload): void;
+    handleMessageToolCallStart(payload: NcpToolCallStartPayload): void;
+    handleMessageToolCallArgs(payload: NcpToolCallArgsPayload): void;
+    handleMessageToolCallArgsDelta(payload: NcpToolCallArgsDeltaPayload): void;
+    handleMessageToolCallEnd(payload: NcpToolCallEndPayload): void;
+    handleMessageToolCallResult(payload: NcpToolCallResultPayload): void;
+    handleRunStarted(_payload: NcpRunStartedPayload): void;
+    handleRunFinished(_payload: NcpRunFinishedPayload): void;
+    handleRunError(payload: NcpRunErrorPayload): void;
+    handleRunMetadata(_payload: NcpRunMetadataPayload): void;
+    handleEndpointError(payload: NcpError): void;
+    private applyToolCallArgs;
+    private ensureStreamingMessage;
+    private resolveToolCallTargetMessage;
+    private updateMessageContainingToolCall;
+    private findToolInvocationPart;
+    private findToolNameByCallId;
+    private upsertToolInvocationPart;
+    private findLastReasoningPartIndex;
+    private upsertMessage;
+    private replaceStreamingMessage;
+    private setError;
+    private clearToolCallTrackingByMessageId;
+}
+
+export { DefaultNcpAgentConversationStateManager };

package/dist/index.js

@@ -0,0 +1,520 @@
+// src/agent/agent-conversation-state-manager.ts
+var DEFAULT_ASSISTANT_ROLE = "assistant";
+var cloneMessage = (message) => {
+  return {
+    ...message,
+    parts: [...message.parts],
+    metadata: message.metadata ? { ...message.metadata } : void 0
+  };
+};
+var buildRuntimeError = (payload) => {
+  const message = payload.error?.trim();
+  return {
+    code: "runtime-error",
+    message: message && message.length > 0 ? message : "Agent run failed.",
+    details: {
+      sessionKey: payload.sessionKey,
+      messageId: payload.messageId,
+      threadId: payload.threadId,
+      runId: payload.runId
+    }
+  };
+};
+var DefaultNcpAgentConversationStateManager = class {
+  messages = [];
+  streamingMessage = null;
+  error = null;
+  listeners = /* @__PURE__ */ new Set();
+  toolCallMessageIdByCallId = /* @__PURE__ */ new Map();
+  toolCallArgsRawByCallId = /* @__PURE__ */ new Map();
+  stateVersion = 0;
+  getSnapshot() {
+    return {
+      messages: this.messages.map((message) => cloneMessage(message)),
+      streamingMessage: this.streamingMessage ? cloneMessage(this.streamingMessage) : null,
+      error: this.error ? { ...this.error, details: this.error.details ? { ...this.error.details } : void 0 } : null
+    };
+  }
+  subscribe(listener) {
+    this.listeners.add(listener);
+    return () => this.listeners.delete(listener);
+  }
+  dispatch(event) {
+    const versionBeforeDispatch = this.stateVersion;
+    switch (event.type) {
+      case "message.request":
+        this.handleMessageRequest(event.payload);
+        break;
+      case "message.sent":
+        this.handleMessageSent(event.payload);
+        break;
+      case "message.accepted":
+        this.handleMessageAccepted(event.payload);
+        break;
+      case "message.incoming":
+        this.handleMessageIncoming(event.payload);
+        break;
+      case "message.completed":
+        this.handleMessageCompleted(event.payload);
+        break;
+      case "message.failed":
+        this.handleMessageFailed(event.payload);
+        break;
+      case "message.abort":
+        this.handleMessageAbort(event.payload);
+        break;
+      case "message.text-start":
+        this.handleMessageTextStart(event.payload);
+        break;
+      case "message.text-delta":
+        this.handleMessageTextDelta(event.payload);
+        break;
+      case "message.text-end":
+        this.handleMessageTextEnd(event.payload);
+        break;
+      case "message.reasoning-start":
+        this.handleMessageReasoningStart(event.payload);
+        break;
+      case "message.reasoning-delta":
+        this.handleMessageReasoningDelta(event.payload);
+        break;
+      case "message.reasoning-end":
+        this.handleMessageReasoningEnd(event.payload);
+        break;
+      case "message.tool-call-start":
+        this.handleMessageToolCallStart(event.payload);
+        break;
+      case "message.tool-call-args":
+        this.handleMessageToolCallArgs(event.payload);
+        break;
+      case "message.tool-call-args-delta":
+        this.handleMessageToolCallArgsDelta(event.payload);
+        break;
+      case "message.tool-call-end":
+        this.handleMessageToolCallEnd(event.payload);
+        break;
+      case "message.tool-call-result":
+        this.handleMessageToolCallResult(event.payload);
+        break;
+      case "run.started":
+        this.handleRunStarted(event.payload);
+        break;
+      case "run.finished":
+        this.handleRunFinished(event.payload);
+        break;
+      case "run.error":
+        this.handleRunError(event.payload);
+        break;
+      case "run.metadata":
+        this.handleRunMetadata(event.payload);
+        break;
+      case "endpoint.error":
+        this.handleEndpointError(event.payload);
+        break;
+      case "endpoint.ready":
+      case "typing.start":
+      case "typing.end":
+      case "presence.updated":
+      case "message.read":
+      case "message.delivered":
+      case "message.recalled":
+      case "message.reaction":
+        break;
+      default:
+        break;
+    }
+    if (this.stateVersion !== versionBeforeDispatch) {
+      const snapshot = this.getSnapshot();
+      for (const listener of this.listeners) {
+        listener(snapshot);
+      }
+    }
+  }
+  handleMessageRequest(payload) {
+    this.upsertMessage(payload.message);
+    this.setError(null);
+  }
+  handleMessageSent(payload) {
+    this.upsertMessage(payload.message);
+    this.setError(null);
+  }
+  handleMessageAccepted(_payload) {
+  }
+  handleMessageIncoming(payload) {
+    const incomingMessage = cloneMessage(payload.message);
+    if (incomingMessage.status === "streaming" || incomingMessage.status === "pending") {
+      this.replaceStreamingMessage(incomingMessage);
+      this.setError(null);
+      return;
+    }
+    this.upsertMessage(incomingMessage);
+    if (this.streamingMessage?.id === incomingMessage.id) {
+      this.replaceStreamingMessage(null);
+      this.clearToolCallTrackingByMessageId(incomingMessage.id);
+    }
+    this.setError(null);
+  }
+  handleMessageCompleted(payload) {
+    const completedMessage = {
+      ...cloneMessage(payload.message),
+      status: "final"
+    };
+    this.upsertMessage(completedMessage);
+    if (this.streamingMessage?.id === completedMessage.id) {
+      this.replaceStreamingMessage(null);
+    }
+    this.clearToolCallTrackingByMessageId(completedMessage.id);
+    this.setError(null);
+  }
+  handleMessageFailed(payload) {
+    this.setError(payload.error);
+    const targetMessageId = payload.messageId?.trim();
+    if (!targetMessageId) {
+      return;
+    }
+    if (this.streamingMessage?.id === targetMessageId) {
+      this.upsertMessage({
+        ...this.streamingMessage,
+        status: "error"
+      });
+      this.replaceStreamingMessage(null);
+      this.clearToolCallTrackingByMessageId(targetMessageId);
+      return;
+    }
+    const messageIndex = this.messages.findIndex((message) => message.id === targetMessageId);
+    if (messageIndex < 0) {
+      return;
+    }
+    const nextMessages = [...this.messages];
+    nextMessages[messageIndex] = {
+      ...nextMessages[messageIndex],
+      status: "error"
+    };
+    this.messages = nextMessages;
+    this.stateVersion += 1;
+  }
+  handleMessageAbort(payload) {
+    const targetMessageId = payload.messageId?.trim();
+    this.setError({
+      code: "abort-error",
+      message: "Message aborted.",
+      details: {
+        messageId: targetMessageId,
+        correlationId: payload.correlationId
+      }
+    });
+    if (this.streamingMessage && (!targetMessageId || this.streamingMessage.id === targetMessageId)) {
+      this.upsertMessage({
+        ...this.streamingMessage,
+        status: "error"
+      });
+      this.replaceStreamingMessage(null);
+      if (targetMessageId) {
+        this.clearToolCallTrackingByMessageId(targetMessageId);
+      }
+    }
+  }
+  handleMessageTextStart(payload) {
+    this.ensureStreamingMessage(payload.sessionKey, payload.messageId, "streaming");
+    this.setError(null);
+  }
+  handleMessageTextDelta(payload) {
+    if (!payload.delta) {
+      return;
+    }
+    const targetMessage = this.ensureStreamingMessage(payload.sessionKey, payload.messageId, "streaming");
+    const nextParts = [...targetMessage.parts];
+    const lastPart = nextParts[nextParts.length - 1];
+    if (lastPart?.type === "text") {
+      nextParts[nextParts.length - 1] = {
+        type: "text",
+        text: `${lastPart.text}${payload.delta}`
+      };
+    } else {
+      nextParts.push({ type: "text", text: payload.delta });
+    }
+    this.replaceStreamingMessage({
+      ...targetMessage,
+      parts: nextParts,
+      status: "streaming"
+    });
+  }
+  handleMessageTextEnd(payload) {
+    if (this.streamingMessage?.id !== payload.messageId) {
+      return;
+    }
+    if (this.streamingMessage.status !== "streaming") {
+      return;
+    }
+    this.replaceStreamingMessage({
+      ...this.streamingMessage,
+      status: "pending"
+    });
+  }
+  handleMessageReasoningStart(payload) {
+    this.ensureStreamingMessage(payload.sessionKey, payload.messageId, "streaming");
+  }
+  handleMessageReasoningDelta(payload) {
+    if (!payload.delta) {
+      return;
+    }
+    const targetMessage = this.ensureStreamingMessage(payload.sessionKey, payload.messageId, "streaming");
+    const nextParts = [...targetMessage.parts];
+    const reasoningPartIndex = this.findLastReasoningPartIndex(nextParts);
+    if (reasoningPartIndex >= 0) {
+      const existingPart = nextParts[reasoningPartIndex];
+      if (existingPart?.type === "reasoning") {
+        nextParts[reasoningPartIndex] = {
+          type: "reasoning",
+          text: `${existingPart.text}${payload.delta}`
+        };
+      }
+    } else {
+      nextParts.push({ type: "reasoning", text: payload.delta });
+    }
+    this.replaceStreamingMessage({
+      ...targetMessage,
+      parts: nextParts,
+      status: "streaming"
+    });
+  }
+  handleMessageReasoningEnd(payload) {
+    if (this.streamingMessage?.id !== payload.messageId) {
+      return;
+    }
+  }
+  handleMessageToolCallStart(payload) {
+    const targetMessage = this.resolveToolCallTargetMessage(
+      payload.sessionKey,
+      payload.toolCallId,
+      payload.messageId
+    );
+    this.toolCallArgsRawByCallId.set(payload.toolCallId, "");
+    const nextParts = this.upsertToolInvocationPart(targetMessage.parts, {
+      type: "tool-invocation",
+      toolCallId: payload.toolCallId,
+      toolName: payload.toolName,
+      state: "partial-call",
+      args: ""
+    });
+    this.replaceStreamingMessage({
+      ...targetMessage,
+      parts: nextParts,
+      status: "streaming"
+    });
+    this.setError(null);
+  }
+  handleMessageToolCallArgs(payload) {
+    this.toolCallArgsRawByCallId.set(payload.toolCallId, payload.args);
+    this.applyToolCallArgs(payload.sessionKey, payload.toolCallId, payload.args);
+  }
+  handleMessageToolCallArgsDelta(payload) {
+    const currentArgs = this.toolCallArgsRawByCallId.get(payload.toolCallId) ?? "";
+    const nextArgs = `${currentArgs}${payload.delta}`;
+    this.toolCallArgsRawByCallId.set(payload.toolCallId, nextArgs);
+    this.applyToolCallArgs(payload.sessionKey, payload.toolCallId, nextArgs, payload.messageId);
+  }
+  handleMessageToolCallEnd(payload) {
+    const targetMessage = this.resolveToolCallTargetMessage(payload.sessionKey, payload.toolCallId);
+    const args = this.toolCallArgsRawByCallId.get(payload.toolCallId) ?? "";
+    const nextParts = this.upsertToolInvocationPart(targetMessage.parts, {
+      type: "tool-invocation",
+      toolCallId: payload.toolCallId,
+      toolName: this.findToolNameByCallId(targetMessage.parts, payload.toolCallId) ?? "unknown",
+      state: "call",
+      args
+    });
+    this.replaceStreamingMessage({
+      ...targetMessage,
+      parts: nextParts,
+      status: "streaming"
+    });
+  }
+  handleMessageToolCallResult(payload) {
+    const updated = this.updateMessageContainingToolCall(payload.toolCallId, (targetMessage, existingPart) => {
+      const mergedPart = {
+        type: "tool-invocation",
+        toolCallId: payload.toolCallId,
+        toolName: existingPart.toolName,
+        state: "result",
+        args: existingPart.args,
+        result: payload.content
+      };
+      return this.upsertToolInvocationPart(targetMessage.parts, mergedPart);
+    });
+    if (!updated) {
+      const fallbackMessage = this.resolveToolCallTargetMessage(payload.sessionKey, payload.toolCallId);
+      const nextParts = this.upsertToolInvocationPart(fallbackMessage.parts, {
+        type: "tool-invocation",
+        toolCallId: payload.toolCallId,
+        toolName: "unknown",
+        state: "result",
+        result: payload.content
+      });
+      this.replaceStreamingMessage({
+        ...fallbackMessage,
+        parts: nextParts,
+        status: "streaming"
+      });
+    }
+  }
+  handleRunStarted(_payload) {
+    this.setError(null);
+  }
+  handleRunFinished(_payload) {
+  }
+  handleRunError(payload) {
+    this.setError(buildRuntimeError(payload));
+  }
+  handleRunMetadata(_payload) {
+  }
+  handleEndpointError(payload) {
+    this.setError(payload);
+  }
+  applyToolCallArgs(sessionKey, toolCallId, args, messageId) {
+    const targetMessage = this.resolveToolCallTargetMessage(sessionKey, toolCallId, messageId);
+    const toolName = this.findToolNameByCallId(targetMessage.parts, toolCallId) ?? "unknown";
+    const nextParts = this.upsertToolInvocationPart(targetMessage.parts, {
+      type: "tool-invocation",
+      toolCallId,
+      toolName,
+      state: "partial-call",
+      args
+    });
+    this.replaceStreamingMessage({
+      ...targetMessage,
+      parts: nextParts,
+      status: "streaming"
+    });
+  }
+  ensureStreamingMessage(sessionKey, messageId, status) {
+    if (this.streamingMessage?.id === messageId) {
+      if (this.streamingMessage.status === status) {
+        return this.streamingMessage;
+      }
+      const nextStreamingMessage2 = {
+        ...this.streamingMessage,
+        status
+      };
+      this.replaceStreamingMessage(nextStreamingMessage2);
+      return nextStreamingMessage2;
+    }
+    const nextStreamingMessage = {
+      id: messageId,
+      sessionKey,
+      role: DEFAULT_ASSISTANT_ROLE,
+      status,
+      parts: [],
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    this.replaceStreamingMessage(nextStreamingMessage);
+    return nextStreamingMessage;
+  }
+  resolveToolCallTargetMessage(sessionKey, toolCallId, messageId) {
+    const preferredMessageId = messageId?.trim() || this.toolCallMessageIdByCallId.get(toolCallId) || this.streamingMessage?.id || `tool-${toolCallId}`;
+    this.toolCallMessageIdByCallId.set(toolCallId, preferredMessageId);
+    return this.ensureStreamingMessage(sessionKey, preferredMessageId, "streaming");
+  }
+  updateMessageContainingToolCall(toolCallId, updater) {
+    if (this.streamingMessage) {
+      const part = this.findToolInvocationPart(this.streamingMessage.parts, toolCallId);
+      if (part) {
+        const nextParts = updater(this.streamingMessage, part);
+        this.replaceStreamingMessage({ ...this.streamingMessage, parts: nextParts });
+        return true;
+      }
+    }
+    for (let index = this.messages.length - 1; index >= 0; index -= 1) {
+      const candidateMessage = this.messages[index];
+      const part = this.findToolInvocationPart(candidateMessage.parts, toolCallId);
+      if (!part) {
+        continue;
+      }
+      const nextMessages = [...this.messages];
+      nextMessages[index] = {
+        ...candidateMessage,
+        parts: updater(candidateMessage, part)
+      };
+      this.messages = nextMessages;
+      this.stateVersion += 1;
+      return true;
+    }
+    return false;
+  }
+  findToolInvocationPart(parts, toolCallId) {
+    for (let index = parts.length - 1; index >= 0; index -= 1) {
+      const part = parts[index];
+      if (part.type === "tool-invocation" && part.toolCallId === toolCallId) {
+        return part;
+      }
+    }
+    return null;
+  }
+  findToolNameByCallId(parts, toolCallId) {
+    const part = this.findToolInvocationPart(parts, toolCallId);
+    return part?.toolName ?? null;
+  }
+  upsertToolInvocationPart(parts, toolPart) {
+    const nextParts = [...parts];
+    for (let index = nextParts.length - 1; index >= 0; index -= 1) {
+      const part = nextParts[index];
+      if (part.type === "tool-invocation" && part.toolCallId === toolPart.toolCallId) {
+        nextParts[index] = {
+          ...part,
+          ...toolPart
+        };
+        return nextParts;
+      }
+    }
+    nextParts.push(toolPart);
+    return nextParts;
+  }
+  findLastReasoningPartIndex(parts) {
+    for (let index = parts.length - 1; index >= 0; index -= 1) {
+      if (parts[index]?.type === "reasoning") {
+        return index;
+      }
+    }
+    return -1;
+  }
+  upsertMessage(message) {
+    const normalizedMessage = cloneMessage(message);
+    const messageIndex = this.messages.findIndex((item) => item.id === normalizedMessage.id);
+    if (messageIndex < 0) {
+      this.messages = [...this.messages, normalizedMessage];
+      this.stateVersion += 1;
+      return;
+    }
+    const nextMessages = [...this.messages];
+    nextMessages[messageIndex] = normalizedMessage;
+    this.messages = nextMessages;
+    this.stateVersion += 1;
+  }
+  replaceStreamingMessage(nextStreamingMessage) {
+    if (!nextStreamingMessage && !this.streamingMessage) {
+      return;
+    }
+    this.streamingMessage = nextStreamingMessage ? cloneMessage(nextStreamingMessage) : null;
+    this.stateVersion += 1;
+  }
+  setError(nextError) {
+    const hasSameError = this.error?.code === nextError?.code && this.error?.message === nextError?.message && this.error?.details === nextError?.details && this.error?.cause === nextError?.cause;
+    if (hasSameError) {
+      return;
+    }
+    this.error = nextError ? { ...nextError, details: nextError.details ? { ...nextError.details } : void 0 } : null;
+    this.stateVersion += 1;
+  }
+  clearToolCallTrackingByMessageId(messageId) {
+    for (const [toolCallId, trackedMessageId] of this.toolCallMessageIdByCallId) {
+      if (trackedMessageId !== messageId) {
+        continue;
+      }
+      this.toolCallMessageIdByCallId.delete(toolCallId);
+      this.toolCallArgsRawByCallId.delete(toolCallId);
+    }
+  }
+};
+export {
+  DefaultNcpAgentConversationStateManager
+};

package/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "@nextclaw/ncp-toolkit",
+  "version": "0.1.0",
+  "private": false,
+  "description": "Toolkit implementations built on top of the NextClaw Communication Protocol.",
+  "type": "module",
+  "exports": {
+    ".": {
+      "development": "./src/index.ts",
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "@nextclaw/ncp": "0.1.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.17.6",
+    "@typescript-eslint/eslint-plugin": "^7.18.0",
+    "@typescript-eslint/parser": "^7.18.0",
+    "eslint": "^8.57.1",
+    "eslint-config-prettier": "^9.1.0",
+    "prettier": "^3.3.3",
+    "tsup": "^8.3.5",
+    "typescript": "^5.6.3",
+    "vitest": "^2.1.2"
+  },
+  "scripts": {
+    "build": "tsup src/index.ts --format esm --dts --out-dir dist",
+    "lint": "eslint .",
+    "tsc": "tsc -p tsconfig.json",
+    "test": "vitest run"
+  }
+}