Function runTool

mcp/src/tools/util.ts:38–73

(fn: () => Promise<T>)

} as const;

export async function runTool<T>(fn: () => Promise<T>): Promise<ToolResult> {
  try {
    const result = await fn();
    const text =
      result === undefined
        ? "OK"
        : typeof result === "string"
          ? result
          : JSON.stringify(result, null, 2);
    return { content: [{ type: "text", text }] };
  } catch (err) {
    // Surface the API envelope's machine-branchable `code` (§6a #4) so an agent
    // can branch on a stable code (e.g. domain_not_verified, message_not_pending,
    // recipient_suppressed) instead of parsing prose. The retryable hint tells
    // it whether a retry could ever help. Errors thrown by the wrapper itself
    // (plain Error — e.g. "email is required") have no code and fall through to
    // the prose form.
    if (err instanceof E2AError && err.code) {
      const retry = err.retryable ? " (retryable)" : "";
      // Only the `code` (a trusted snake_case token) goes inside the brackets.
      // The message is free-form and can echo caller/recipient input, so bound +
      // sanitize it: strip control chars/newlines (keep the `[code]` convention
      // parseable) and cap length (avoid context blowup). We surface code +
      // message only — never the raw response body, headers, or request_id.
      return {
        content: [{ type: "text", text: `e2a error [${err.code}]${retry}: ${sanitizeMessage(err.message)}` }],
        isError: true,
      };
    }
    const message = err instanceof Error ? err.message : String(err);
    return {
      content: [{ type: "text", text: `e2a error: ${sanitizeMessage(message)}` }],
      isError: true,
    };
  }
}

// sanitizeMessage makes an error message safe to splice into the single-line
// `[code]: <message>` tool-error text: collapse control chars / newlines to