@absol-labs/agent 0.1.0

package/src/frameworks/agentkit.ts

@@ -0,0 +1,537 @@
+import "reflect-metadata";
+
+import type {
+  HireComputeResult,
+  StreamProofClientConfig,
+} from "@absol-labs/sdk";
+import {
+  ActionProvider,
+  CreateAction,
+  WalletProvider,
+  type Network,
+} from "@coinbase/agentkit";
+import { isAddress, isHex } from "viem";
+import { z } from "zod";
+
+import {
+  discoverServices as defaultDiscoverServices,
+  type DiscoverServicesOptions,
+  type ServiceListing,
+} from "../discovery/registry.js";
+import { checkMandate, type SignedSpendMandate } from "../mandates/mandate.js";
+import {
+  MandateDeniedError,
+  VerifiedStreamAgentClient,
+  type AgentSdkClientFactory,
+  type MandateAuthorizedStreamActionInput,
+  type OpenVerifiedStreamInput,
+  type ReclaimAuthorizedStreamInput,
+  type ReclaimVerifiedStreamResult,
+  type StreamProofTransactionResult,
+  type StreamStatusView,
+} from "../sdk/client.js";
+
+/**
+ * Base Sepolia is the only settlement network Metrik supports today (Model A,
+ * single-chain USDC on Base). Every action fails closed on any other network.
+ */
+export const METRIK_BASE_SEPOLIA_CHAIN_ID = 84532;
+
+const addressSchema = z
+  .string()
+  .refine((value) => isAddress(value), "must be an EVM address");
+const bytes32Schema = z
+  .string()
+  .refine(
+    (value) => isHex(value, { strict: true }) && value.length === 66,
+    "must be bytes32 hex",
+  );
+const decimalStringSchema = z.preprocess(
+  (value) =>
+    typeof value === "bigint" || typeof value === "number"
+      ? value.toString()
+      : value,
+  z
+    .string()
+    .regex(
+      /^(0|[1-9]\d*)$/,
+      "must be a base-10 integer string (USDC atomic units, 6 decimals)",
+    ),
+);
+
+export const discoverServicesSchema = z.object({
+  category: z
+    .string()
+    .min(1)
+    .optional()
+    .describe("Optional marketplace category to filter listings by."),
+  limit: z
+    .number()
+    .int()
+    .positive()
+    .optional()
+    .describe("Optional cap on the number of verified listings to return."),
+});
+
+export const hireVerifiedServiceSchema = z.object({
+  operator: addressSchema.describe(
+    "Seller payout wallet (EVM address) that receives USDC for verified delivery.",
+  ),
+  serviceRef: bytes32Schema.describe(
+    "bytes32 service identifier the oracle verifies delivery against.",
+  ),
+  budgetUsdc: decimalStringSchema.describe(
+    "Total USDC to escrow for this stream, in atomic units (6 decimals).",
+  ),
+  ratePerSecondUsdc: decimalStringSchema.describe(
+    "Accrual rate to the seller per verified second, in USDC atomic units.",
+  ),
+  durationSeconds: z
+    .number()
+    .int()
+    .positive()
+    .optional()
+    .describe(
+      "Optional max stream lifetime in seconds. Defaults to the mandate's max duration.",
+    ),
+  publicUrl: z
+    .string()
+    .url()
+    .optional()
+    .describe("Optional service endpoint URL, recorded in the human summary."),
+});
+
+export const checkStreamStatusSchema = z.object({
+  streamId: bytes32Schema.describe(
+    "The stream id returned by hire_verified_service.",
+  ),
+});
+
+export const reclaimUnspentSchema = z.object({
+  streamId: bytes32Schema.describe(
+    "The stream id to reclaim unspent USDC from.",
+  ),
+  closeFirst: z
+    .boolean()
+    .optional()
+    .describe(
+      "Close the stream before reclaiming. Use when the stream is still active.",
+    ),
+});
+
+export const closeStreamSchema = z.object({
+  streamId: bytes32Schema.describe("The stream id to close."),
+});
+
+/**
+ * Resolves the mutable, per-owner mandate accounting the guard needs: how much
+ * of the total cap has already been spent, and which mandate ids are revoked.
+ */
+export interface MetrikMandateStateResolver {
+  getSpentSoFarUsdc(owner: `0x${string}`): Promise<bigint>;
+  getRevokedMandateIds(owner: `0x${string}`): Promise<readonly `0x${string}`[]>;
+}
+
+const DEFAULT_MANDATE_STATE_RESOLVER: MetrikMandateStateResolver = {
+  getSpentSoFarUsdc: async () => 0n,
+  getRevokedMandateIds: async () => [],
+};
+
+/**
+ * The subset of the Metrik SDK the action provider drives. `VerifiedStreamAgentClient`
+ * satisfies this structurally; tests inject a lightweight double so the provider
+ * is exercisable with no CDP creds and no RPC.
+ */
+export interface MetrikAgentKitClient {
+  openVerifiedStream(
+    input: OpenVerifiedStreamInput,
+  ): Promise<HireComputeResult>;
+  getStreamStatus(streamId: `0x${string}`): Promise<StreamStatusView>;
+  reclaimStream(
+    input: ReclaimAuthorizedStreamInput,
+  ): Promise<ReclaimVerifiedStreamResult>;
+  closeStream(
+    input: MandateAuthorizedStreamActionInput,
+  ): Promise<StreamProofTransactionResult>;
+}
+
+export interface MetrikActionProviderConfig {
+  /**
+   * The owner-signed spend mandate that bounds every hire (per-stream + total
+   * budget, rate, duration, allowed operators). Configured once at the
+   * agent's construction — the LLM never supplies or edits it.
+   */
+  readonly signedMandate: SignedSpendMandate;
+  /** Settlement chain id. Defaults to Base Sepolia (84532); any other value fails closed. */
+  readonly chainId?: number;
+  /** Injected Metrik client (test path). Mutually exclusive with `sdkConfig`. */
+  readonly agentClient?: MetrikAgentKitClient;
+  /**
+   * Metrik SDK config (escrow address, chain, rpc, signing account) used to
+   * BUILD a `VerifiedStreamAgentClient` when no `agentClient` is injected. The
+   * signing account comes from the CDP wallet in `createMetrikAgentKit`.
+   */
+  readonly sdkConfig?: StreamProofClientConfig;
+  /** Optional SDK client factory override, forwarded to the built client. */
+  readonly createSdkClient?: AgentSdkClientFactory;
+  /** Mandate accounting source. Defaults to fresh state (0 spent, none revoked). */
+  readonly mandateStateResolver?: Partial<MetrikMandateStateResolver>;
+  /** Clock injection for deterministic tests. Defaults to wall-clock seconds. */
+  readonly now?: () => number;
+  /**
+   * Discovery driver for the `discover_services` action. Defaults to the live
+   * registry-backed `discoverServices`; tests inject a double.
+   */
+  readonly discoverServices?: (
+    opts?: DiscoverServicesOptions,
+  ) => Promise<ServiceListing[]>;
+}
+
+const warnedAgentKitGaps = new Set<string>();
+
+/** Emits a stderr warning at most once per process for a given key. */
+function warnAgentKitOnce(key: string, message: string): void {
+  if (warnedAgentKitGaps.has(key)) {
+    return;
+  }
+  warnedAgentKitGaps.add(key);
+  console.error(message);
+}
+
+export class MetrikActionProviderConfigError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = "MetrikActionProviderConfigError";
+  }
+}
+
+/**
+ * Coinbase AgentKit action provider that lets any AgentKit-based agent hire and
+ * pay third-party services through Metrik's verified USDC escrow. Every action
+ * is fail-closed and buyer-favoring; a hire is refused before any transaction if
+ * it would breach the configured spend mandate.
+ */
+export class MetrikActionProvider extends ActionProvider<WalletProvider> {
+  readonly #client: MetrikAgentKitClient;
+  readonly #signedMandate: SignedSpendMandate;
+  readonly #resolver: MetrikMandateStateResolver;
+  readonly #now: () => number;
+  readonly #chainId: number;
+  readonly #discover: (
+    opts?: DiscoverServicesOptions,
+  ) => Promise<ServiceListing[]>;
+
+  constructor(config: MetrikActionProviderConfig) {
+    super("metrik", []);
+
+    this.#chainId = config.chainId ?? METRIK_BASE_SEPOLIA_CHAIN_ID;
+    if (this.#chainId !== METRIK_BASE_SEPOLIA_CHAIN_ID) {
+      // Fail closed: Model A settles only on Base Sepolia today.
+      throw new MetrikActionProviderConfigError(
+        `unsupported chainId ${this.#chainId}: Metrik settles only on Base Sepolia (${METRIK_BASE_SEPOLIA_CHAIN_ID})`,
+      );
+    }
+
+    this.#client = resolveClient(config);
+    this.#signedMandate = config.signedMandate;
+    this.#resolver = {
+      ...DEFAULT_MANDATE_STATE_RESOLVER,
+      ...config.mandateStateResolver,
+    };
+    // Fail-loud on the two mandate controls that require external state. The
+    // action provider holds no stream registry, so without a wired resolver the
+    // cumulative cap (maxTotalUsdc) and revocation are not enforced. Warn once.
+    if (config.mandateStateResolver?.getSpentSoFarUsdc === undefined) {
+      warnAgentKitOnce(
+        "agentkit-spent",
+        "[metrik] AgentKit provider: no getSpentSoFarUsdc wired — the mandate cumulative cap (maxTotalUsdc) is NOT enforced across hires (per-stream/rate/duration/operator/expiry still are).",
+      );
+    }
+    if (config.mandateStateResolver?.getRevokedMandateIds === undefined) {
+      warnAgentKitOnce(
+        "agentkit-revocation",
+        "[metrik] AgentKit provider: no getRevokedMandateIds wired — revoked mandates will NOT be rejected until you wire a revocation store.",
+      );
+    }
+    this.#now = config.now ?? (() => Math.floor(Date.now() / 1000));
+    this.#discover = config.discoverServices ?? defaultDiscoverServices;
+  }
+
+  @CreateAction({
+    name: "discover_services",
+    description:
+      "Discover verified third-party services on the Metrik marketplace. Returns each seller's payout operator, bytes32 serviceRef, and endpoint URL — but only for listings whose operator signature is cryptographically verified, so the agent can go straight from discovery to hire_verified_service without pre-known addresses.",
+    schema: discoverServicesSchema,
+  })
+  async discoverServices(
+    _walletProvider: WalletProvider,
+    args: z.infer<typeof discoverServicesSchema>,
+  ): Promise<string> {
+    const listings = await this.#discover({
+      ...(args.category === undefined ? {} : { category: args.category }),
+      ...(args.limit === undefined ? {} : { limit: args.limit }),
+    });
+    if (listings.length === 0) {
+      return "No verified Metrik services discovered.";
+    }
+    const lines = listings.map(
+      (listing) =>
+        `- ${listing.serviceRef} operator=${listing.operator} url=${listing.publicUrl}${listing.category ? ` category=${listing.category}` : ""}`,
+    );
+    return (
+      `Discovered ${listings.length} verified Metrik service${listings.length === 1 ? "" : "s"} ` +
+      `(each operator signature verified). Hire one with hire_verified_service using its operator + serviceRef:\n` +
+      lines.join("\n")
+    );
+  }
+
+  @CreateAction({
+    name: "hire_verified_service",
+    description:
+      "Hire a third-party service through Metrik: escrow USDC on Base for a per-second verified-delivery stream to the seller. Payment accrues only for delivery the oracle proves, and unspent funds are reclaimable. Refuses before any transaction if the hire would exceed the signed spend mandate.",
+    schema: hireVerifiedServiceSchema,
+  })
+  async hireVerifiedService(
+    walletProvider: WalletProvider,
+    args: z.infer<typeof hireVerifiedServiceSchema>,
+  ): Promise<string> {
+    this.#assertWalletNetwork(walletProvider);
+
+    const owner = this.#signedMandate.owner as `0x${string}`;
+    const nowSeconds = this.#now();
+    const [spentSoFarUsdc, revokedMandateIds] = await Promise.all([
+      this.#resolver.getSpentSoFarUsdc(owner),
+      this.#resolver.getRevokedMandateIds(owner),
+    ]);
+
+    const operator = args.operator as `0x${string}`;
+    const serviceRef = args.serviceRef as `0x${string}`;
+    const budgetUsdc = BigInt(args.budgetUsdc);
+    const ratePerSecondUsdc = BigInt(args.ratePerSecondUsdc);
+    const maxDurationSeconds =
+      args.durationSeconds ?? this.#signedMandate.mandate.maxDurationSeconds;
+
+    // Mandate guard runs BEFORE any transaction — fail closed on breach.
+    const decision = await checkMandate(
+      this.#signedMandate,
+      {
+        operator,
+        budgetUsdc,
+        ratePerSecondUsdc,
+        maxDurationSeconds,
+      },
+      spentSoFarUsdc,
+      { nowSeconds, revokedMandateIds },
+    );
+    if (!decision.allowed) {
+      throw new MandateDeniedError(decision.reason ?? "mandate-expired");
+    }
+
+    const result = await this.#client.openVerifiedStream({
+      operator,
+      serviceRef,
+      budgetUsdc,
+      ratePerSecondUsdc,
+      maxDurationSeconds,
+      signedMandate: this.#signedMandate,
+      spentSoFarUsdc,
+      nowSeconds,
+      revokedMandateIds,
+    });
+
+    const urlLine = args.publicUrl ? ` Endpoint: ${args.publicUrl}.` : "";
+    return (
+      `Hired verified service via Metrik. Stream ${result.streamId} opened on Base Sepolia (escrow ${result.handle.escrow}). ` +
+      `Escrowed ${formatUsdc(budgetUsdc)} USDC at ${formatUsdc(ratePerSecondUsdc)} USDC/sec to operator ${operator} for service ${serviceRef}, ` +
+      `max ${maxDurationSeconds}s. Payment accrues only for oracle-verified delivery; unspent USDC is reclaimable.${urlLine} ` +
+      `tx=${result.txHash}${result.approveTxHash ? ` approve=${result.approveTxHash}` : ""}`
+    );
+  }
+
+  @CreateAction({
+    name: "check_stream_status",
+    description:
+      "Read a Metrik stream's status: verified accrued amount, whether it is active or paused (two failed checks auto-pause), claimable-by-seller, and reclaimable-by-buyer USDC.",
+    schema: checkStreamStatusSchema,
+  })
+  async checkStreamStatus(
+    walletProvider: WalletProvider,
+    args: z.infer<typeof checkStreamStatusSchema>,
+  ): Promise<string> {
+    this.#assertWalletNetwork(walletProvider);
+
+    const streamId = args.streamId as `0x${string}`;
+    const { stream, claimable, reclaimable } =
+      await this.#client.getStreamStatus(streamId);
+    const paused = stream.status !== "active";
+
+    return (
+      `Stream ${streamId} is ${stream.status}${paused ? " (payment halted)" : ""}. ` +
+      `Verified accrued: ${formatUsdc(stream.accrued)} USDC of ${formatUsdc(stream.deposit)} deposited. ` +
+      `Claimable by seller: ${formatUsdc(claimable)} USDC. Reclaimable by buyer: ${formatUsdc(reclaimable)} USDC. ` +
+      `Consecutive failed checks: ${stream.consecutiveFailures}.`
+    );
+  }
+
+  @CreateAction({
+    name: "reclaim_unspent",
+    description:
+      "Reclaim unspent escrowed USDC from a Metrik stream back to the buyer. Set closeFirst to close an active stream before reclaiming. Runs under the same signed mandate controls.",
+    schema: reclaimUnspentSchema,
+  })
+  async reclaimUnspent(
+    walletProvider: WalletProvider,
+    args: z.infer<typeof reclaimUnspentSchema>,
+  ): Promise<string> {
+    this.#assertWalletNetwork(walletProvider);
+
+    const result = await this.#client.reclaimStream(
+      await this.#authorizedStreamAction(args.streamId as `0x${string}`, {
+        ...(args.closeFirst === undefined
+          ? {}
+          : { closeFirst: args.closeFirst }),
+      }),
+    );
+
+    return (
+      `Reclaimed unspent USDC from stream ${args.streamId} to the buyer. ` +
+      `${result.closeResult ? `Closed first (tx=${result.closeResult.txHash}). ` : ""}` +
+      `reclaim tx=${result.reclaimResult.txHash}`
+    );
+  }
+
+  @CreateAction({
+    name: "close_stream",
+    description:
+      "Close a Metrik stream, finalizing accrual and stopping further payment. Runs under the same signed mandate controls.",
+    schema: closeStreamSchema,
+  })
+  async closeStream(
+    walletProvider: WalletProvider,
+    args: z.infer<typeof closeStreamSchema>,
+  ): Promise<string> {
+    this.#assertWalletNetwork(walletProvider);
+
+    const result = await this.#client.closeStream(
+      await this.#authorizedStreamAction(args.streamId as `0x${string}`, {}),
+    );
+    return `Closed stream ${args.streamId}. tx=${result.txHash}`;
+  }
+
+  supportsNetwork(network: Network): boolean {
+    // Fail closed: EVM Base Sepolia only.
+    return (
+      network.protocolFamily === "evm" &&
+      network.chainId === String(this.#chainId)
+    );
+  }
+
+  #assertWalletNetwork(walletProvider: WalletProvider): void {
+    const network = walletProvider.getNetwork();
+    if (!this.supportsNetwork(network)) {
+      throw new MetrikActionProviderConfigError(
+        `unsupported network ${network.protocolFamily}:${network.chainId ?? "unknown"}: Metrik requires Base Sepolia (evm:${this.#chainId})`,
+      );
+    }
+  }
+
+  async #authorizedStreamAction<TExtra extends object>(
+    streamId: `0x${string}`,
+    extra: TExtra,
+  ): Promise<MandateAuthorizedStreamActionInput & TExtra> {
+    const owner = this.#signedMandate.owner as `0x${string}`;
+    const nowSeconds = this.#now();
+    const [spentSoFarUsdc, revokedMandateIds] = await Promise.all([
+      this.#resolver.getSpentSoFarUsdc(owner),
+      this.#resolver.getRevokedMandateIds(owner),
+    ]);
+    return {
+      streamId,
+      signedMandate: this.#signedMandate,
+      spentSoFarUsdc,
+      nowSeconds,
+      revokedMandateIds,
+      ...extra,
+    };
+  }
+}
+
+/**
+ * Factory mirroring AgentKit's `xxxActionProvider()` convention.
+ */
+export function metrikActionProvider(
+  config: MetrikActionProviderConfig,
+): MetrikActionProvider {
+  return new MetrikActionProvider(config);
+}
+
+export interface CreateMetrikAgentKitOptions {
+  /**
+   * A concrete AgentKit wallet provider (e.g. `CdpEvmWalletProvider` or
+   * `CdpSmartWalletProvider`) built from the CDP creds. Constructing it reaches
+   * CDP and therefore needs live creds at runtime; the action provider itself is
+   * independently unit-testable without any creds.
+   */
+  readonly walletProvider: WalletProvider;
+  readonly metrik: MetrikActionProviderConfig;
+  /** Additional AgentKit action providers to compose alongside Metrik. */
+  readonly additionalActionProviders?: readonly ActionProvider[];
+}
+
+/**
+ * Convenience that composes Metrik into an AgentKit instance alongside the CDP
+ * wallet provider. From the returned `AgentKit` you can expose Metrik natively
+ * via `getLangChainTools`, `getVercelAITools`, or the AgentKit MCP server.
+ */
+export async function createMetrikAgentKit(
+  options: CreateMetrikAgentKitOptions,
+) {
+  const { AgentKit } = await import("@coinbase/agentkit");
+  return AgentKit.from({
+    walletProvider: options.walletProvider,
+    actionProviders: [
+      metrikActionProvider(options.metrik),
+      ...(options.additionalActionProviders ?? []),
+    ],
+  });
+}
+
+function resolveClient(
+  config: MetrikActionProviderConfig,
+): MetrikAgentKitClient {
+  if (config.agentClient !== undefined) {
+    if (config.sdkConfig !== undefined) {
+      throw new MetrikActionProviderConfigError(
+        "provide either agentClient or sdkConfig, not both",
+      );
+    }
+    return config.agentClient;
+  }
+  if (config.sdkConfig !== undefined) {
+    return new VerifiedStreamAgentClient(
+      config.sdkConfig,
+      config.createSdkClient === undefined
+        ? {}
+        : { createSdkClient: config.createSdkClient },
+    );
+  }
+  throw new MetrikActionProviderConfigError(
+    "MetrikActionProvider requires either an injected agentClient or an sdkConfig (escrow address, chain, rpc, signing account)",
+  );
+}
+
+const USDC_DECIMALS = 6n;
+const USDC_SCALE = 10n ** USDC_DECIMALS;
+
+function formatUsdc(atomic: bigint): string {
+  const whole = atomic / USDC_SCALE;
+  const fraction = atomic % USDC_SCALE;
+  if (fraction === 0n) {
+    return whole.toString();
+  }
+  const fractionStr = fraction
+    .toString()
+    .padStart(Number(USDC_DECIMALS), "0")
+    .replace(/0+$/, "");
+  return `${whole.toString()}.${fractionStr}`;
+}

package/src/frameworks/crewai.ts

@@ -0,0 +1,102 @@
+export const CREWAI_VERIFIED_STREAM_TOOL_NAMES = [
+  "discover_services",
+  "hire_verified_service",
+  "check_stream_status",
+  "reclaim_unspent",
+  "list_streams",
+] as const;
+
+export interface CrewAiVerifiedStreamMcpConfig {
+  readonly transport: "stdio";
+  readonly command: string;
+  readonly args: readonly string[];
+  readonly env: Readonly<Record<string, string>>;
+  readonly allowedToolNames: readonly string[];
+  readonly cacheToolsList: boolean;
+}
+
+export interface CrewAiVerifiedStreamMcpConfigOptions {
+  readonly command?: string;
+  readonly args?: readonly string[];
+  readonly env?: Readonly<Record<string, string>>;
+  readonly allowedToolNames?: readonly string[];
+  readonly cacheToolsList?: boolean;
+}
+
+export function createCrewAiVerifiedStreamMcpConfig(
+  options: CrewAiVerifiedStreamMcpConfigOptions = {},
+): CrewAiVerifiedStreamMcpConfig {
+  return {
+    transport: "stdio",
+    command: options.command ?? "pnpm",
+    args: options.args ?? ["mcp:stdio"],
+    env: options.env ?? {},
+    allowedToolNames:
+      options.allowedToolNames ?? CREWAI_VERIFIED_STREAM_TOOL_NAMES,
+    cacheToolsList: options.cacheToolsList ?? true,
+  };
+}
+
+export function renderCrewAiVerifiedStreamPythonExample(
+  options: CrewAiVerifiedStreamMcpConfigOptions = {},
+): string {
+  const config = createCrewAiVerifiedStreamMcpConfig(options);
+  const envEntries = Object.entries(config.env)
+    .map(
+      ([key, value]) =>
+        `        "${escapePythonString(key)}": "${escapePythonString(value)}",`,
+    )
+    .join("\n");
+  const toolNames = config.allowedToolNames
+    .map((name) => `            "${escapePythonString(name)}",`)
+    .join("\n");
+
+  return [
+    "from crewai import Agent, Crew, Task",
+    "from crewai.mcp import MCPServerStdio",
+    "from crewai.mcp.filters import create_static_tool_filter",
+    "",
+    "metrik_mcp = MCPServerStdio(",
+    `    command="${escapePythonString(config.command)}",`,
+    `    args=${renderPythonList(config.args)},`,
+    "    env={",
+    envEntries,
+    "    },",
+    "    tool_filter=create_static_tool_filter(",
+    "        allowed_tool_names=[",
+    toolNames,
+    "        ]",
+    "    ),",
+    `    cache_tools_list=${config.cacheToolsList ? "True" : "False"},`,
+    ")",
+    "",
+    "buyer_agent = Agent(",
+    '    role="Verified Compute Buyer",',
+    '    goal="Hire a verified service and stop work when the stream pauses.",',
+    '    backstory="An operator that only pays for oracle-verified delivery.",',
+    "    mcps=[metrik_mcp],",
+    ")",
+    "",
+    "task = Task(",
+    '    description="Use hire_verified_service to open a stream, then call check_stream_status to monitor it.",',
+    '    expected_output="A stream id plus the current verified stream status.",',
+    "    agent=buyer_agent,",
+    ")",
+    "",
+    "crew = Crew(agents=[buyer_agent], tasks=[task])",
+    "result = crew.kickoff()",
+    "print(result)",
+    "",
+  ].join("\n");
+}
+
+function renderPythonList(values: readonly string[]): string {
+  const rendered = values
+    .map((value) => `"${escapePythonString(value)}"`)
+    .join(", ");
+  return `[${rendered}]`;
+}
+
+function escapePythonString(value: string): string {
+  return value.replaceAll("\\", "\\\\").replaceAll('"', '\\"');
+}